Index: source/API/SBAddress.cpp
===================================================================
--- source/API/SBAddress.cpp
+++ source/API/SBAddress.cpp
@@ -120,8 +120,8 @@
   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
+  // 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())
@@ -163,9 +163,9 @@
 }
 
 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;
 }
@@ -173,8 +173,8 @@
 Address *SBAddress::get() { return m_opaque_ap.get(); }
 
 bool SBAddress::GetDescription(SBStream &description) {
-  // Call "ref()" on the stream to make sure it creates a backing stream in
-  // case there isn't one already...
+  // Call "ref()" on the stream to make sure it creates a backing stream
+  // in case there isn't one already...
   Stream &strm = description.ref();
   if (m_opaque_ap->IsValid()) {
     m_opaque_ap->Dump(&strm, NULL, Address::DumpStyleResolvedDescription,
Index: source/API/SBCommandInterpreter.cpp
===================================================================
--- source/API/SBCommandInterpreter.cpp
+++ source/API/SBCommandInterpreter.cpp
@@ -272,8 +272,8 @@
   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;
 
Index: source/API/SBDebugger.cpp
===================================================================
--- source/API/SBDebugger.cpp
+++ source/API/SBDebugger.cpp
@@ -69,10 +69,10 @@
     typedef bool (*LLDBCommandPluginInit)(lldb::SBDebugger & debugger);
 
     lldb::SBDebugger debugger_sb(debugger_sp);
-    // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger)
-    // function.
-    // TODO: mangle this differently for your system - on OSX, the first
-    // underscore needs to be removed and the second one stays
+    // This calls the bool lldb::PluginInitialize(lldb::SBDebugger
+    // debugger) function. TODO: mangle this differently for your system -
+    // on OSX, the first underscore needs to be removed and the second one
+    // stays
     LLDBCommandPluginInit init_func =
         (LLDBCommandPluginInit)(uintptr_t)dynlib.getAddressOfSymbol(
             "_ZN4lldb16PluginInitializeENS_10SBDebuggerE");
@@ -167,15 +167,12 @@
 
   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.
+  // 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.
   static std::recursive_mutex g_mutex;
   std::lock_guard<std::recursive_mutex> guard(g_mutex);
 
@@ -256,9 +253,9 @@
     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));
 
@@ -838,7 +835,8 @@
     }
     ++idx;
   }
-  // +1 for the host platform, which should always appear first in the list.
+  // +1 for the host platform, which should always appear first in the
+  // list.
   return idx + 1;
 }
 
Index: source/API/SBError.cpp
===================================================================
--- source/API/SBError.cpp
+++ source/API/SBError.cpp
@@ -154,7 +154,8 @@
 }
 
 const lldb_private::Status &SBError::operator*() const {
-  // Be sure to call "IsValid()" before calling this function or it will crash
+  // Be sure to call "IsValid()" before calling this function or it will
+  // crash
   return *m_opaque_ap;
 }
 
Index: source/API/SBEvent.cpp
===================================================================
--- source/API/SBEvent.cpp
+++ source/API/SBEvent.cpp
@@ -107,8 +107,8 @@
   if (lldb_event)
     success = lldb_event->BroadcasterIs(broadcaster.get());
 
-  // For logging, this gets a little chatty so only enable this when verbose
-  // logging is on
+  // For logging, this gets a little chatty so only enable this when
+  // verbose logging is on
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   LLDB_LOGV(log, "({0}) (SBBroadcaster({1}): {2}) => {3}", get(),
             broadcaster.get(), broadcaster.GetName(), success);
@@ -125,10 +125,10 @@
 EventSP &SBEvent::GetSP() const { return m_event_sp; }
 
 Event *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_ptr...
+  // 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_ptr...
   if (m_event_sp)
     m_opaque_ptr = m_event_sp.get();
 
Index: source/API/SBFrame.cpp
===================================================================
--- source/API/SBFrame.cpp
+++ source/API/SBFrame.cpp
@@ -1026,7 +1026,8 @@
                   break;
                 }
                 if (add_variable) {
-                  // Only add variables once so we don't end up with duplicates
+                  // Only add variables once so we don't end up with
+                  // duplicates
                   if (variable_set.find(variable_sp) == variable_set.end())
                     variable_set.insert(variable_sp);
                   else
Index: source/API/SBInstruction.cpp
===================================================================
--- source/API/SBInstruction.cpp
+++ source/API/SBInstruction.cpp
@@ -27,24 +27,22 @@
 #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)
-// 3  if (inst.DoesBranch())
-// 4  ...
+// 2  inst = target.ReadInstructions(pc, 1).GetInstructionAtIndex(0) 3  if
+// (inst.DoesBranch()) 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
+// 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 {
@@ -204,8 +202,9 @@
     if (module_sp)
       module_sp->ResolveSymbolContextForAddress(addr, eSymbolContextEverything,
                                                 sc);
-    // Use the "ref()" instead of the "get()" accessor in case the SBStream
-    // didn't have a stream already created, one will get created...
+    // Use the "ref()" instead of the "get()" accessor in case the
+    // SBStream didn't have a stream already created, one will get
+    // created...
     FormatEntity::Entry format;
     FormatEntity::Parse("${addr}: ", format);
     inst_sp->Dump(&s.ref(), 0, true, false, NULL, &sc, NULL, &format, 0);
Index: source/API/SBLaunchInfo.cpp
===================================================================
--- source/API/SBLaunchInfo.cpp
+++ source/API/SBLaunchInfo.cpp
@@ -148,8 +148,8 @@
 }
 
 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();
 }
Index: source/API/SBModule.cpp
===================================================================
--- source/API/SBModule.cpp
+++ source/API/SBModule.cpp
@@ -167,9 +167,9 @@
   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
+    // 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 +515,9 @@
   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();
   }
Index: source/API/SBModuleSpec.cpp
===================================================================
--- source/API/SBModuleSpec.cpp
+++ source/API/SBModuleSpec.cpp
@@ -70,9 +70,9 @@
 
 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();
 }
Index: source/API/SBPlatform.cpp
===================================================================
--- source/API/SBPlatform.cpp
+++ source/API/SBPlatform.cpp
@@ -280,8 +280,8 @@
   if (platform_sp) {
     ArchSpec arch(platform_sp->GetSystemArchitecture());
     if (arch.IsValid()) {
-      // Const-ify the string so we don't need to worry about the lifetime of
-      // the string
+      // Const-ify the string so we don't need to worry about the lifetime
+      // of the string
       return ConstString(arch.GetTriple().getTriple().c_str()).GetCString();
     }
   }
@@ -294,8 +294,8 @@
     std::string s;
     if (platform_sp->GetOSBuildString(s)) {
       if (!s.empty()) {
-        // Const-ify the string so we don't need to worry about the lifetime of
-        // the string
+        // Const-ify the string so we don't need to worry about the
+        // lifetime of the string
         return ConstString(s.c_str()).GetCString();
       }
     }
@@ -309,8 +309,8 @@
     std::string s;
     if (platform_sp->GetOSKernelDescription(s)) {
       if (!s.empty()) {
-        // Const-ify the string so we don't need to worry about the lifetime of
-        // the string
+        // Const-ify the string so we don't need to worry about the
+        // lifetime of the string
         return ConstString(s.c_str()).GetCString();
       }
     }
Index: source/API/SBProcess.cpp
===================================================================
--- source/API/SBProcess.cpp
+++ source/API/SBProcess.cpp
@@ -896,8 +896,8 @@
   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());
   }
 
Index: source/API/SBQueueItem.cpp
===================================================================
--- source/API/SBQueueItem.cpp
+++ source/API/SBQueueItem.cpp
@@ -111,9 +111,8 @@
       ConstString type_const(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
+        // Save this in the Process' ExtendedThreadList so a strong
+        // pointer retains the object
         process_sp->GetExtendedThreadList().AddThread(thread_sp);
         result.SetThread(thread_sp);
         if (log) {
Index: source/API/SBStream.cpp
===================================================================
--- source/API/SBStream.cpp
+++ source/API/SBStream.cpp
@@ -60,8 +60,8 @@
 
   std::string local_data;
   if (m_opaque_ap.get()) {
-    // See if we have any locally backed data. If so, copy it so we can then
-    // redirect it to the file so we don't lose the data
+    // See if we have any locally backed data. If so, copy it so we can
+    // then redirect it to the file so we don't lose the data
     if (!m_is_file)
       local_data = static_cast<StreamString *>(m_opaque_ap.get())->GetString();
   }
@@ -79,8 +79,8 @@
   if (m_opaque_ap.get()) {
     m_is_file = true;
 
-    // If we had any data locally in our StreamString, then pass that along to
-    // the to new file we are redirecting to.
+    // If we had any data locally in our StreamString, then pass that
+    // along to the to new file we are redirecting to.
     if (!local_data.empty())
       m_opaque_ap->Write(&local_data[0], local_data.size());
   } else
@@ -93,8 +93,8 @@
 
   std::string local_data;
   if (m_opaque_ap.get()) {
-    // See if we have any locally backed data. If so, copy it so we can then
-    // redirect it to the file so we don't lose the data
+    // See if we have any locally backed data. If so, copy it so we can
+    // then redirect it to the file so we don't lose the data
     if (!m_is_file)
       local_data = static_cast<StreamString *>(m_opaque_ap.get())->GetString();
   }
@@ -103,8 +103,8 @@
   if (m_opaque_ap.get()) {
     m_is_file = true;
 
-    // If we had any data locally in our StreamString, then pass that along to
-    // the to new file we are redirecting to.
+    // If we had any data locally in our StreamString, then pass that
+    // along to the to new file we are redirecting to.
     if (!local_data.empty())
       m_opaque_ap->Write(&local_data[0], local_data.size());
   } else
@@ -114,8 +114,8 @@
 void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) {
   std::string local_data;
   if (m_opaque_ap.get()) {
-    // See if we have any locally backed data. If so, copy it so we can then
-    // redirect it to the file so we don't lose the data
+    // See if we have any locally backed data. If so, copy it so we can
+    // then redirect it to the file so we don't lose the data
     if (!m_is_file)
       local_data = static_cast<StreamString *>(m_opaque_ap.get())->GetString();
   }
@@ -124,8 +124,8 @@
   if (m_opaque_ap.get()) {
     m_is_file = true;
 
-    // If we had any data locally in our StreamString, then pass that along to
-    // the to new file we are redirecting to.
+    // If we had any data locally in our StreamString, then pass that
+    // along to the to new file we are redirecting to.
     if (!local_data.empty())
       m_opaque_ap->Write(&local_data[0], local_data.size());
   } else
@@ -144,8 +144,8 @@
 
 void SBStream::Clear() {
   if (m_opaque_ap.get()) {
-    // See if we have any locally backed data. If so, copy it so we can then
-    // redirect it to the file so we don't lose the data
+    // See if we have any locally backed data. If so, copy it so we can
+    // then redirect it to the file so we don't lose the data
     if (m_is_file)
       m_opaque_ap.reset();
     else
Index: source/API/SBTarget.cpp
===================================================================
--- source/API/SBTarget.cpp
+++ source/API/SBTarget.cpp
@@ -84,8 +84,8 @@
     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 @@
 
     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");
@@ -593,8 +593,9 @@
       return sb_addr;
   }
 
-  // We have a load address that isn't in a section, just return an address
-  // with the offset filled in (the address) and the section set to NULL
+  // We have a load address that isn't in a section, just return an
+  // address with the offset filled in (the address) and the section set
+  // to NULL
   addr.SetRawAddress(vm_addr);
   return sb_addr;
 }
@@ -624,8 +625,9 @@
       return sb_addr;
   }
 
-  // We have a load address that isn't in a section, just return an address
-  // with the offset filled in (the address) and the section set to NULL
+  // We have a load address that isn't in a section, just return an
+  // address with the offset filled in (the address) and the section set
+  // to NULL
   addr.SetRawAddress(vm_addr);
   return sb_addr;
 }
@@ -1543,9 +1545,9 @@
   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 +1697,8 @@
       }
     }
 
-    // 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());
 
Index: source/API/SBThread.cpp
===================================================================
--- source/API/SBThread.cpp
+++ source/API/SBThread.cpp
@@ -614,9 +614,8 @@
     return sb_error;
   }
 
-  // User level plans should be Master Plans so they can be interrupted, other
-  // plans executed, and
-  // then a "continue" will resume the plan.
+  // User level plans should be Master Plans so they can be interrupted,
+  // other plans executed, and then a "continue" will resume the plan.
   if (new_plan != NULL) {
     new_plan->SetIsMasterPlan(true);
     new_plan->SetOkayToDiscard(false);
@@ -908,11 +907,10 @@
       }
     }
 
-    // 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.
+    // 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.
 
     bool all_in_function = true;
     AddressRange fun_range = frame_sc.function->GetAddressRange();
@@ -1374,8 +1372,7 @@
                 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) {
Index: source/API/SBThreadPlan.cpp
===================================================================
--- source/API/SBThreadPlan.cpp
+++ source/API/SBThreadPlan.cpp
@@ -134,12 +134,11 @@
     return false;
 }
 
-// This section allows an SBThreadPlan to push another of the common types of
-// plans...
+// This section allows an SBThreadPlan to push another of the common types
+// of 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.
+// 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.
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepOverRange(SBAddress &sb_start_address,
Index: source/API/SBType.cpp
===================================================================
--- source/API/SBType.cpp
+++ source/API/SBType.cpp
@@ -89,8 +89,8 @@
 
 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.
+  // 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;
 }
Index: source/API/SBTypeCategory.cpp
===================================================================
--- source/API/SBTypeCategory.cpp
+++ source/API/SBTypeCategory.cpp
@@ -338,12 +338,11 @@
   if (!summary.IsValid())
     return false;
 
-  // 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
+  // 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
   if (summary.IsFunctionCode()) {
     const void *name_token =
         (const void *)ConstString(type_name.GetName()).GetCString();
@@ -450,12 +449,11 @@
   if (!synth.IsValid())
     return false;
 
-  // 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
+  // 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
   if (synth.IsClassCode()) {
     const void *name_token =
         (const void *)ConstString(type_name.GetName()).GetCString();
Index: source/API/SBValue.cpp
===================================================================
--- source/API/SBValue.cpp
+++ source/API/SBValue.cpp
@@ -86,19 +86,16 @@
     if (m_valobj_sp.get() == NULL)
       return false;
     else {
-      // 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
+      // 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
       // tracking that in all the ValueObject subclasses.
       TargetSP target_sp = m_valobj_sp->GetTargetSP();
       if (target_sp && target_sp->IsValid())
@@ -129,9 +126,9 @@
 
     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()));
@@ -169,12 +166,11 @@
 
   bool GetUseSynthetic() { return m_use_synthetic; }
 
-  // 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.
+  // 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.
   TargetSP GetTargetSP() {
     if (m_valobj_sp)
       return m_valobj_sp->GetTargetSP();
@@ -243,8 +239,8 @@
 
 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.
+  // 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;
 }
@@ -991,7 +987,8 @@
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
-    // using default values for all the fancy options, just do it if you can
+    // using default values for all the fancy options, just do it if you
+    // can
     child_sp = value_sp->GetValueForExpressionPath(expr_path);
   }
 
@@ -1397,11 +1394,9 @@
         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());
       }
     }
@@ -1515,7 +1510,8 @@
                                   SBError &error) {
   SBWatchpoint sb_watchpoint;
 
-  // If the SBValue is not valid, there's no point in even trying to watch it.
+  // If the SBValue is not valid, there's no point in even trying to watch
+  // it.
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   TargetSP target_sp(GetTarget().GetSP());
@@ -1579,9 +1575,8 @@
   return sb_watchpoint;
 }
 
-// FIXME: Remove this method impl (as well as the decl in .h) once it is no
-// longer needed.
-// Backward compatibility fix in the interim.
+// FIXME: Remove this method impl (as well as the decl in .h) once it is
+// no longer needed. Backward compatibility fix in the interim.
 lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read,
                                   bool write) {
   SBError error;
Index: source/API/SystemInitializerFull.cpp
===================================================================
--- source/API/SystemInitializerFull.cpp
+++ source/API/SystemInitializerFull.cpp
@@ -138,11 +138,11 @@
 #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 +262,9 @@
 #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 +362,8 @@
   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,9 +381,9 @@
   // 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
-  // AFTER PluginManager::Initialize is called.
+  // The process settings need to know about installed plug-ins, so the
+  // Settings must be initialized AFTER PluginManager::Initialize is
+  // called.
 
   Debugger::SettingsInitialize();
 }
Index: source/Breakpoint/Breakpoint.cpp
===================================================================
--- source/Breakpoint/Breakpoint.cpp
+++ source/Breakpoint/Breakpoint.cpp
@@ -290,8 +290,8 @@
 // the breakpoint vs. its locations.
 
 // Disable at the breakpoint level should override the location settings.
-// That way you can conveniently turn off a whole breakpoint without messing
-// up the individual settings.
+// That way you can conveniently turn off a whole breakpoint without
+// messing up the individual settings.
 
 void Breakpoint::SetEnabled(bool enable) {
   if (enable == m_options_up->IsEnabled())
@@ -330,11 +330,10 @@
 bool Breakpoint::IgnoreCountShouldStop() {
   uint32_t ignore = GetIgnoreCount();
   if (ignore != 0) {
-    // When we get here we know the location that caused the stop doesn't have
-    // an ignore count,
-    // since by contract we call it first...  So we don't have to find &
-    // decrement it, we only have
-    // to decrement our own ignore count.
+    // When we get here we know the location that caused the stop doesn't
+    // have an ignore count, since by contract we call it first...  So we
+    // don't have to find & decrement it, we only have to decrement our
+    // own ignore count.
     DecrementIgnoreCount();
     return false;
   } else
@@ -478,8 +477,7 @@
                                             bool send_event) {
   if (m_resolver_sp) {
     // If this is not an internal breakpoint, set up to record the new
-    // locations, then dispatch
-    // an event with the new locations.
+    // locations, then dispatch an event with the new locations.
     if (!IsInternal() && send_event) {
       BreakpointEventData *new_locations_event = new BreakpointEventData(
           eBreakpointEventTypeLocationsAdded, shared_from_this());
@@ -517,14 +515,14 @@
   std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
   if (load) {
     // The logic for handling new modules is:
-    // 1) If the filter rejects this module, then skip it.
-    // 2) Run through the current location list and if there are any locations
+    // 1) If the filter rejects this module, then skip it. 2) Run through
+    // the current location list and if there are any locations
     //    for that module, we mark the module as "seen" and we don't try to
     //    re-resolve
     //    breakpoint locations for that module.
     //    However, we do add breakpoint sites to these locations if needed.
-    // 3) If we don't see this module in our breakpoint location list, call
-    // ResolveInModules.
+    // 3) If we don't see this module in our breakpoint location list,
+    // call ResolveInModules.
 
     ModuleList new_modules; // We'll stuff the "unseen" modules in this list,
                             // and then resolve
@@ -540,9 +538,9 @@
       for (BreakpointLocationSP break_loc_sp :
            m_locations.BreakpointLocations()) {
 
-        // If the section for this location was deleted, that means
-        // it's Module has gone away but somebody forgot to tell us.
-        // Let's clean it up here.
+        // If the section for this location was deleted, that means it's
+        // Module has gone away but somebody forgot to tell us. Let's
+        // clean it up here.
         Address section_addr(break_loc_sp->GetAddress());
         if (section_addr.SectionWasDeleted()) {
           locations_with_no_section.Add(break_loc_sp);
@@ -554,9 +552,9 @@
         
         SectionSP section_sp(section_addr.GetSection());
         
-        // If we don't have a Section, that means this location is a raw address
-        // that we haven't resolved to a section yet.  So we'll have to look
-        // in all the new modules to resolve this location.
+        // If we don't have a Section, that means this location is a raw
+        // address that we haven't resolved to a section yet.  So we'll
+        // have to look in all the new modules to resolve this location.
         // Otherwise, if it was set in this module, re-resolve it here.
         if (section_sp && section_sp->GetModule() == module_sp) {
           if (!seen)
@@ -584,9 +582,9 @@
       ResolveBreakpointInModules(new_modules);
     }
   } else {
-    // Go through the currently set locations and if any have breakpoints in
-    // the module list, then remove their breakpoint sites, and their locations
-    // if asked to.
+    // Go through the currently set locations and if any have breakpoints
+    // in the module list, then remove their breakpoint sites, and their
+    // locations if asked to.
 
     BreakpointEventData *removed_locations_event;
     if (!IsInternal())
@@ -607,9 +605,8 @@
           SectionSP section_sp(break_loc_sp->GetAddress().GetSection());
           if (section_sp && section_sp->GetModule() == module_sp) {
             // Remove this breakpoint since the shared library is
-            // unloaded, but keep the breakpoint location around
-            // so we always get complete hit count and breakpoint
-            // lifetime info
+            // unloaded, but keep the breakpoint location around so we
+            // always get complete hit count and breakpoint lifetime info
             break_loc_sp->ClearBreakpointSite();
             if (removed_locations_event) {
               removed_locations_event->GetBreakpointLocationCollection().Add(
@@ -637,7 +634,8 @@
   bool equivalent_scs = false;
 
   if (old_sc.module_sp.get() == new_sc.module_sp.get()) {
-    // If these come from the same module, we can directly compare the pointers:
+    // If these come from the same module, we can directly compare the
+    // pointers:
     if (old_sc.comp_unit && new_sc.comp_unit &&
         (old_sc.comp_unit == new_sc.comp_unit)) {
       if (old_sc.function && new_sc.function &&
@@ -688,21 +686,19 @@
   size_t num_old_locations = old_break_locs.GetSize();
 
   if (num_old_locations == 0) {
-    // There were no locations in the old module, so we just need to check if
-    // there were any in the new module.
+    // There were no locations in the old module, so we just need to check
+    // if there were any in the new module.
     ModuleList temp_list;
     temp_list.Append(new_module_sp);
     ResolveBreakpointInModules(temp_list);
   } else {
-    // First search the new module for locations.
-    // Then compare this with the old list, copy over locations that "look the
-    // same"
-    // Then delete the old locations.
-    // Finally remember to post the creation event.
+    // First search the new module for locations. Then compare this with
+    // the old list, copy over locations that "look the same" Then delete
+    // the old locations. Finally remember to post the creation event.
     //
-    // Two locations are the same if they have the same comp unit & function (by
-    // name) and there are the same number
-    // of locations in the old function as in the new one.
+    // Two locations are the same if they have the same comp unit &
+    // function (by name) and there are the same number of locations in
+    // the old function as in the new one.
 
     ModuleList temp_list;
     temp_list.Append(new_module_sp);
@@ -714,14 +710,14 @@
     size_t num_new_locations = new_break_locs.GetSize();
 
     if (num_new_locations > 0) {
-      // Break out the case of one location -> one location since that's the
-      // most common one, and there's no need
-      // to build up the structures needed for the merge in that case.
+      // Break out the case of one location -> one location since that's
+      // the most common one, and there's no need to build up the
+      // structures needed for the merge in that case.
       if (num_new_locations == 1 && num_old_locations == 1) {
         bool equivalent_locations = false;
         SymbolContext old_sc, new_sc;
-        // The only way the old and new location can be equivalent is if they
-        // have the same amount of information:
+        // The only way the old and new location can be equivalent is if
+        // they have the same amount of information:
         BreakpointLocationSP old_loc_sp = old_break_locs.GetByIndex(0);
         BreakpointLocationSP new_loc_sp = new_break_locs.GetByIndex(0);
 
@@ -738,9 +734,8 @@
           locations_to_announce.Add(new_loc_sp);
         }
       } else {
-        // We don't want to have to keep computing the SymbolContexts for these
-        // addresses over and over,
-        // so lets get them up front:
+        // We don't want to have to keep computing the SymbolContexts for
+        // these addresses over and over, so lets get them up front:
 
         typedef std::map<lldb::break_id_t, SymbolContext> IDToSCMap;
         IDToSCMap old_sc_map;
@@ -763,7 +758,8 @@
           lldb::break_id_t old_id = old_sc_map.begin()->first;
           SymbolContext &old_sc = old_sc_map.begin()->second;
 
-          // Count the number of entries equivalent to this SC for the old list:
+          // Count the number of entries equivalent to this SC for the old
+          // list:
           std::vector<lldb::break_id_t> old_id_vec;
           old_id_vec.push_back(old_id);
 
@@ -783,13 +779,11 @@
           }
 
           // Alright, if we have the same number of potentially equivalent
-          // locations in the old
-          // and new modules, we'll just map them one to one in ascending ID
-          // order (assuming the
-          // resolver's order would match the equivalent ones.
-          // Otherwise, we'll dump all the old ones, and just take the new ones,
-          // erasing the elements
-          // from both maps as we go.
+          // locations in the old and new modules, we'll just map them one
+          // to one in ascending ID order (assuming the resolver's order
+          // would match the equivalent ones. Otherwise, we'll dump all
+          // the old ones, and just take the new ones, erasing the
+          // elements from both maps as we go.
 
           if (old_id_vec.size() == new_id_vec.size()) {
             llvm::sort(old_id_vec.begin(), old_id_vec.end());
@@ -820,13 +814,11 @@
       }
     }
 
-    // Now remove the remaining old locations, and cons up a removed locations
-    // event.
-    // Note, we don't put the new locations that were swapped with an old
-    // location on the locations_to_remove
-    // list, so we don't need to worry about telling the world about removing a
-    // location we didn't tell them
-    // about adding.
+    // Now remove the remaining old locations, and cons up a removed
+    // locations event. Note, we don't put the new locations that were
+    // swapped with an old location on the locations_to_remove list, so we
+    // don't need to worry about telling the world about removing a
+    // location we didn't tell them about adding.
 
     BreakpointEventData *locations_event;
     if (!IsInternal())
@@ -888,10 +880,9 @@
   const size_t num_locations = GetNumLocations();
   const size_t num_resolved_locations = GetNumResolvedLocations();
 
-  // They just made the breakpoint, they don't need to be told HOW they made
-  // it...
-  // Also, we'll print the breakpoint number differently depending on whether
-  // there is 1 or more locations.
+  // They just made the breakpoint, they don't need to be told HOW they
+  // made it... Also, we'll print the breakpoint number differently
+  // depending on whether there is 1 or more locations.
   if (level != eDescriptionLevelInitial) {
     s->Printf("%i: ", GetID());
     GetResolverDescription(s);
@@ -907,9 +898,9 @@
         s->Printf(", resolved = %" PRIu64 ", hit count = %d",
                   (uint64_t)num_resolved_locations, GetHitCount());
     } else {
-      // Don't print the pending notification for exception resolvers since we
-      // don't generally
-      // know how to set them until the target is run.
+      // Don't print the pending notification for exception resolvers
+      // since we don't generally know how to set them until the target is
+      // run.
       if (m_resolver_sp->getResolverID() !=
           BreakpointResolver::ExceptionResolver)
         s->Printf(", locations = 0 (pending)");
@@ -964,9 +955,9 @@
     break;
   }
 
-  // The brief description is just the location name (1.2 or whatever).  That's
-  // pointless to
-  // show in the breakpoint's description, so suppress it.
+  // The brief description is just the location name (1.2 or whatever).
+  // That's pointless to show in the breakpoint's description, so suppress
+  // it.
   if (show_locations && level != lldb::eDescriptionLevelBrief) {
     s->IndentMore();
     for (size_t i = 0; i < num_locations; ++i) {
@@ -986,8 +977,8 @@
 bool Breakpoint::GetMatchingFileLine(const ConstString &filename,
                                      uint32_t line_number,
                                      BreakpointLocationCollection &loc_coll) {
-  // TODO: To be correct, this method needs to fill the breakpoint location
-  // collection
+  // TODO: To be correct, this method needs to fill the breakpoint
+  // location collection
   //       with the location IDs which match the filename and line_number.
   //
 
Index: source/Breakpoint/BreakpointID.cpp
===================================================================
--- source/Breakpoint/BreakpointID.cpp
+++ source/Breakpoint/BreakpointID.cpp
@@ -28,11 +28,10 @@
 
 static llvm::StringRef g_range_specifiers[] = {"-", "to", "To", "TO"};
 
-// Tells whether or not STR is valid to use between two strings representing
-// breakpoint IDs, to
-// indicate a range of breakpoint IDs.  This is broken out into a separate
-// function so that we can
-// easily change or add to the format for specifying ID ranges at a later date.
+// Tells whether or not STR is valid to use between two strings
+// representing breakpoint IDs, to indicate a range of breakpoint IDs.
+// This is broken out into a separate function so that we can easily
+// change or add to the format for specifying ID ranges at a later date.
 
 bool BreakpointID::IsRangeIdentifier(llvm::StringRef str) {
   for (auto spec : g_range_specifiers) {
@@ -85,7 +84,8 @@
   if (input.consumeInteger(0, bp_id))
     return llvm::None;
 
-  // period is optional, but if it exists, it must be followed by a number.
+  // period is optional, but if it exists, it must be followed by a
+  // number.
   if (input.consume_front(".")) {
     if (input.consumeInteger(0, loc_id))
       return llvm::None;
Index: source/Breakpoint/BreakpointIDList.cpp
===================================================================
--- source/Breakpoint/BreakpointIDList.cpp
+++ source/Breakpoint/BreakpointIDList.cpp
@@ -236,14 +236,14 @@
       return;
     }
 
-    // We have valid range starting & ending breakpoint IDs.  Go through all
-    // the breakpoints in the target and find all the breakpoints that fit
-    // into this range, and add them to new_args.
+    // We have valid range starting & ending breakpoint IDs.  Go through
+    // all the breakpoints in the target and find all the breakpoints that
+    // fit into this range, and add them to new_args.
 
     // Next check to see if we have location id's.  If so, make sure the
     // start_bp_id and end_bp_id are for the same breakpoint; otherwise we
-    // have an illegal range: breakpoint id ranges that specify bp locations
-    // are NOT allowed to cross major bp id numbers.
+    // have an illegal range: breakpoint id ranges that specify bp
+    // locations are NOT allowed to cross major bp id numbers.
 
     if ((start_loc_id != LLDB_INVALID_BREAK_ID) ||
         (end_loc_id != LLDB_INVALID_BREAK_ID)) {
Index: source/Breakpoint/BreakpointLocation.cpp
===================================================================
--- source/Breakpoint/BreakpointLocation.cpp
+++ source/Breakpoint/BreakpointLocation.cpp
@@ -110,8 +110,8 @@
   if (thread_id != LLDB_INVALID_THREAD_ID)
     GetLocationOptions()->SetThreadID(thread_id);
   else {
-    // If we're resetting this to an invalid thread id, then
-    // don't make an options pointer just to do that.
+    // If we're resetting this to an invalid thread id, then don't make an
+    // options pointer just to do that.
     if (m_options_ap.get() != nullptr)
       m_options_ap->SetThreadID(thread_id);
   }
@@ -132,8 +132,8 @@
   if (index != 0)
     GetLocationOptions()->GetThreadSpec()->SetIndex(index);
   else {
-    // If we're resetting this to an invalid thread id, then
-    // don't make an options pointer just to do that.
+    // If we're resetting this to an invalid thread id, then don't make an
+    // options pointer just to do that.
     if (m_options_ap.get() != nullptr)
       m_options_ap->GetThreadSpec()->SetIndex(index);
   }
@@ -154,8 +154,8 @@
   if (thread_name != nullptr)
     GetLocationOptions()->GetThreadSpec()->SetName(thread_name);
   else {
-    // If we're resetting this to an invalid thread id, then
-    // don't make an options pointer just to do that.
+    // If we're resetting this to an invalid thread id, then don't make an
+    // options pointer just to do that.
     if (m_options_ap.get() != nullptr)
       m_options_ap->GetThreadSpec()->SetName(thread_name);
   }
@@ -176,8 +176,8 @@
   if (queue_name != nullptr)
     GetLocationOptions()->GetThreadSpec()->SetQueueName(queue_name);
   else {
-    // If we're resetting this to an invalid thread id, then
-    // don't make an options pointer just to do that.
+    // If we're resetting this to an invalid thread id, then don't make an
+    // options pointer just to do that.
     if (m_options_ap.get() != nullptr)
       m_options_ap->GetThreadSpec()->SetQueueName(queue_name);
   }
@@ -252,8 +252,8 @@
   if (condition_hash != m_condition_hash || !m_user_expression_sp ||
       !m_user_expression_sp->MatchesContext(exe_ctx)) {
     LanguageType language = eLanguageTypeUnknown;
-    // See if we can figure out the language from the frame, otherwise use the
-    // default language:
+    // See if we can figure out the language from the frame, otherwise use
+    // the default language:
     CompileUnit *comp_unit = m_address.CalculateSymbolContextCompileUnit();
     if (comp_unit)
       language = comp_unit->GetLanguage();
@@ -282,9 +282,9 @@
     m_condition_hash = condition_hash;
   }
 
-  // We need to make sure the user sees any parse errors in their condition, so
-  // we'll hook the
-  // constructor errors up to the debugger's Async I/O.
+  // We need to make sure the user sees any parse errors in their
+  // condition, so we'll hook the constructor errors up to the debugger's
+  // Async I/O.
 
   ValueObjectSP result_value_sp;
 
@@ -372,9 +372,9 @@
 }
 
 BreakpointOptions *BreakpointLocation::GetLocationOptions() {
-  // If we make the copy we don't copy the callbacks because that is potentially
-  // expensive and we don't want to do that for the simple case where someone is
-  // just disabling the location.
+  // If we make the copy we don't copy the callbacks because that is
+  // potentially expensive and we don't want to do that for the simple
+  // case where someone is just disabling the location.
   if (m_options_ap.get() == nullptr)
     m_options_ap.reset(
         new BreakpointOptions(false));
@@ -388,17 +388,17 @@
       ->GetThreadSpecNoCreate());
 }
 
-// RETURNS - true if we should stop at this breakpoint, false if we
-// should continue.  Note, we don't check the thread spec for the breakpoint
-// here, since if the breakpoint is not for this thread, then the event won't
-// even get reported, so the check is redundant.
+// RETURNS - true if we should stop at this breakpoint, false if we should
+// continue.  Note, we don't check the thread spec for the breakpoint
+// here, since if the breakpoint is not for this thread, then the event
+// won't even get reported, so the check is redundant.
 
 bool BreakpointLocation::ShouldStop(StoppointCallbackContext *context) {
   bool should_stop = true;
   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS);
 
-  // Do this first, if a location is disabled, it shouldn't increment its hit
-  // count.
+  // Do this first, if a location is disabled, it shouldn't increment its
+  // hit count.
   if (!IsEnabled())
     return false;
 
@@ -478,10 +478,9 @@
 bool BreakpointLocation::ClearBreakpointSite() {
   if (m_bp_site_sp.get()) {
     ProcessSP process_sp(m_owner.GetTarget().GetProcessSP());
-    // If the process exists, get it to remove the owner, it will remove the
-    // physical implementation
-    // of the breakpoint as well if there are no more owners.  Otherwise just
-    // remove this owner.
+    // If the process exists, get it to remove the owner, it will remove
+    // the physical implementation of the breakpoint as well if there are
+    // no more owners.  Otherwise just remove this owner.
     if (process_sp)
       process_sp->RemoveOwnerFromBreakpointSite(GetBreakpoint().GetID(),
                                                 GetID(), m_bp_site_sp);
@@ -498,9 +497,9 @@
                                         lldb::DescriptionLevel level) {
   SymbolContext sc;
 
-  // If the description level is "initial" then the breakpoint is printing out
-  // our initial state,
-  // and we should let it decide how it wants to print our label.
+  // If the description level is "initial" then the breakpoint is printing
+  // out our initial state, and we should let it decide how it wants to
+  // print our label.
   if (level != eDescriptionLevelInitial) {
     s->Indent();
     BreakpointID::GetCanonicalReference(s, m_owner.GetID(), GetID());
@@ -551,7 +550,8 @@
         }
 
       } else {
-        // If we don't have a comp unit, see if we have a symbol we can print.
+        // If we don't have a comp unit, see if we have a symbol we can
+        // print.
         if (sc.symbol) {
           s->EOL();
           if (IsReExported())
Index: source/Breakpoint/BreakpointLocationList.cpp
===================================================================
--- source/Breakpoint/BreakpointLocationList.cpp
+++ source/Breakpoint/BreakpointLocationList.cpp
@@ -48,13 +48,13 @@
                                         lldb::break_id_t break_id) {
   BreakpointLocationSP bp = FindByID(break_id);
   if (bp) {
-    // Let the BreakpointLocation decide if it should stop here (could not have
-    // reached it's target hit count yet, or it could have a callback
+    // Let the BreakpointLocation decide if it should stop here (could not
+    // have reached it's target hit count yet, or it could have a callback
     // that decided it shouldn't stop (shared library loads/unloads).
     return bp->ShouldStop(context);
   }
-  // We should stop here since this BreakpointLocation isn't valid anymore or it
-  // doesn't exist.
+  // We should stop here since this BreakpointLocation isn't valid anymore
+  // or it doesn't exist.
   return true;
 }
 
@@ -266,13 +266,13 @@
 void BreakpointLocationList::RemoveInvalidLocations(const ArchSpec &arch) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   size_t idx = 0;
-  // Don't cache m_location.size() as it will change since we might
-  // remove locations from our vector...
+  // Don't cache m_location.size() as it will change since we might remove
+  // locations from our vector...
   while (idx < m_locations.size()) {
     BreakpointLocation *bp_loc = m_locations[idx].get();
     if (bp_loc->GetAddress().SectionWasDeleted()) {
-      // Section was deleted which means this breakpoint comes from a module
-      // that is no longer valid, so we should remove it.
+      // Section was deleted which means this breakpoint comes from a
+      // module that is no longer valid, so we should remove it.
       RemoveLocationByIndex(idx);
       continue;
     }
@@ -280,14 +280,15 @@
       ModuleSP module_sp(bp_loc->GetAddress().GetModule());
       if (module_sp) {
         if (!arch.IsCompatibleMatch(module_sp->GetArchitecture())) {
-          // The breakpoint was in a module whose architecture is no longer
-          // compatible with "arch", so we need to remove it
+          // The breakpoint was in a module whose architecture is no
+          // longer compatible with "arch", so we need to remove it
           RemoveLocationByIndex(idx);
           continue;
         }
       }
     }
-    // Only increment the index if we didn't remove the locations at index "idx"
+    // Only increment the index if we didn't remove the locations at index
+    // "idx"
     ++idx;
   }
 }
Index: source/Breakpoint/BreakpointOptions.cpp
===================================================================
--- source/Breakpoint/BreakpointOptions.cpp
+++ source/Breakpoint/BreakpointOptions.cpp
@@ -37,8 +37,8 @@
 BreakpointOptions::CommandData::SerializeToStructuredData() {
   size_t num_strings = user_source.GetSize();
   if (num_strings == 0 && script_source.empty()) {
-    // We shouldn't serialize commands if there aren't any, return an empty sp
-    // to indicate this.
+    // We shouldn't serialize commands if there aren't any, return an
+    // empty sp to indicate this.
     return StructuredData::ObjectSP();
   }
 
@@ -424,15 +424,16 @@
 void BreakpointOptions::SetCallback(BreakpointHitCallback callback,
                                     const lldb::BatonSP &callback_baton_sp,
                                     bool callback_is_synchronous) {
-  // FIXME: This seems unsafe.  If BatonSP actually *is* a CommandBaton, but
-  // in a shared_ptr<Baton> instead of a shared_ptr<CommandBaton>, then we
-  // will set m_baton_is_command_baton to false, which is incorrect.
-  // One possible solution is to make the base Baton class provide a method
-  // such as:
+  // FIXME: This seems unsafe.  If BatonSP actually *is* a CommandBaton,
+  // but in a shared_ptr<Baton> instead of a shared_ptr<CommandBaton>,
+  // then we will set m_baton_is_command_baton to false, which is
+  // incorrect. One possible solution is to make the base Baton class
+  // provide a method such as:
   //     virtual StringRef getBatonId() const { return ""; }
-  // and have CommandBaton override this to return something unique, and then
-  // check for it here.  Another option might be to make Baton using the llvm
-  // casting infrastructure, so that we could write something like:
+  // and have CommandBaton override this to return something unique, and
+  // then check for it here.  Another option might be to make Baton using
+  // the llvm casting infrastructure, so that we could write something
+  // like:
   //     if (llvm::isa<CommandBaton>(callback_baton_sp))
   // at relevant callsites instead of storing a boolean.
   m_callback_is_synchronous = callback_is_synchronous;
@@ -476,8 +477,8 @@
                                           : nullptr,
                       context, break_id, break_loc_id);
     } else if (IsCallbackSynchronous()) {
-      // If a synchronous callback is called at async time, it should not say
-      // to stop.
+      // If a synchronous callback is called at async time, it should not
+      // say to stop.
       return false;
     }
   }
@@ -553,9 +554,8 @@
 
 void BreakpointOptions::GetDescription(Stream *s,
                                        lldb::DescriptionLevel level) const {
-  // Figure out if there are any options not at their default value, and only
-  // print
-  // anything if there are:
+  // Figure out if there are any options not at their default value, and
+  // only print anything if there are:
 
   if (m_ignore_count != 0 || !m_enabled || m_one_shot || m_auto_continue ||
       (GetThreadSpecNoCreate() != nullptr &&
@@ -659,9 +659,9 @@
     if (target) {
       CommandReturnObject result;
       Debugger &debugger = target->GetDebugger();
-      // Rig up the results secondary output stream to the debugger's, so the
-      // output will come out synchronously
-      // if the debugger is set up that way.
+      // Rig up the results secondary output stream to the debugger's, so
+      // the output will come out synchronously if the debugger is set up
+      // that way.
 
       StreamSP output_stream(debugger.GetAsyncOutputStream());
       StreamSP error_stream(debugger.GetAsyncErrorStream());
Index: source/Breakpoint/BreakpointResolver.cpp
===================================================================
--- source/Breakpoint/BreakpointResolver.cpp
+++ source/Breakpoint/BreakpointResolver.cpp
@@ -15,8 +15,8 @@
 // Project includes
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
-// Have to include the other breakpoint resolver types here so the static create
-// from StructuredData can call them.
+// Have to include the other breakpoint resolver types here so the static
+// create from StructuredData can call them.
 #include "lldb/Breakpoint/BreakpointResolverAddress.h"
 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
@@ -192,8 +192,8 @@
     FileSpec match_original_file_spec;
     uint32_t closest_line_number = UINT32_MAX;
 
-    // Pull out the first entry, and all the others that match its file spec,
-    // and stuff them in the tmp list.
+    // Pull out the first entry, and all the others that match its file
+    // spec, and stuff them in the tmp list.
     while (current_idx < sc_list.GetSize()) {
       bool matches;
 
@@ -211,17 +211,17 @@
         tmp_sc_list.Append(sc);
         sc_list.RemoveContextAtIndex(current_idx);
 
-        // ResolveSymbolContext will always return a number that is >= the line
-        // number you pass in.
-        // So the smaller line number is always better.
+        // ResolveSymbolContext will always return a number that is >= the
+        // line number you pass in. So the smaller line number is always
+        // better.
         if (sc.line_entry.line < closest_line_number)
           closest_line_number = sc.line_entry.line;
       } else
         current_idx++;
     }
 
-    // Okay, we've found the closest line number match, now throw away all the
-    // others:
+    // Okay, we've found the closest line number match, now throw away all
+    // the others:
 
     current_idx = 0;
     while (current_idx < tmp_sc_list.GetSize()) {
@@ -234,8 +234,7 @@
     }
 
     // Next go through and see if there are line table entries that are
-    // contiguous, and if so keep only the
-    // first of the contiguous range:
+    // contiguous, and if so keep only the first of the contiguous range:
 
     current_idx = 0;
     std::map<Block *, lldb::addr_t> blocks_with_breakpoints;
@@ -262,7 +261,8 @@
         Address line_start = sc.line_entry.range.GetBaseAddress();
         if (line_start.IsValid()) {
           if (filter.AddressPasses(line_start)) {
-            // If the line number is before the prologue end, move it there...
+            // If the line number is before the prologue end, move it
+            // there...
             bool skipped_prologue = false;
             if (skip_prologue) {
               if (sc.function) {
@@ -315,9 +315,9 @@
 
 void BreakpointResolver::SetOffset(lldb::addr_t offset) {
   // There may already be an offset, so we are actually adjusting location
-  // addresses by the difference.
-  // lldb::addr_t slide = offset - m_offset;
-  // FIXME: We should go fix up all the already set locations for the new slide.
+  // addresses by the difference. lldb::addr_t slide = offset - m_offset;
+  // FIXME: We should go fix up all the already set locations for the new
+  // slide.
 
   m_offset = offset;
 }
Index: source/Breakpoint/BreakpointResolverAddress.cpp
===================================================================
--- source/Breakpoint/BreakpointResolverAddress.cpp
+++ source/Breakpoint/BreakpointResolverAddress.cpp
@@ -100,11 +100,10 @@
 }
 
 void BreakpointResolverAddress::ResolveBreakpoint(SearchFilter &filter) {
-  // If the address is not section relative, then we should not try to
-  // re-resolve it, it is just some
-  // random address and we wouldn't know what to do on reload.  But if it is
-  // section relative, we need to
-  // re-resolve it since the section it's in may have shifted on re-run.
+  // If the address is not section relative, then we should not try to re-
+  // resolve it, it is just some random address and we wouldn't know what
+  // to do on reload.  But if it is section relative, we need to re-
+  // resolve it since the section it's in may have shifted on re-run.
   bool re_resolve = false;
   if (m_addr.GetSection() || m_module_filespec)
     re_resolve = true;
@@ -136,9 +135,9 @@
 
   if (filter.AddressPasses(m_addr)) {
     if (m_breakpoint->GetNumLocations() == 0) {
-      // If the address is just an offset, and we're given a module, see if we
-      // can find the appropriate module
-      // loaded in the binary, and fix up m_addr to use that.
+      // If the address is just an offset, and we're given a module, see
+      // if we can find the appropriate module loaded in the binary, and
+      // fix up m_addr to use that.
       if (!m_addr.IsSectionOffset() && m_module_filespec) {
         Target &target = m_breakpoint->GetTarget();
         ModuleSpec module_spec(m_module_filespec);
Index: source/Breakpoint/BreakpointResolverFileLine.cpp
===================================================================
--- source/Breakpoint/BreakpointResolverFileLine.cpp
+++ source/Breakpoint/BreakpointResolverFileLine.cpp
@@ -108,13 +108,13 @@
   return WrapOptionsDict(options_dict_sp);
 }
 
-// Filter the symbol context list to remove contexts where the line number was
-// moved into a new function. We do this conservatively, so if e.g. we cannot
-// resolve the function in the context (which can happen in case of
-// line-table-only debug info), we leave the context as is. The trickiest part
-// here is handling inlined functions -- in this case we need to make sure we
-// look at the declaration line of the inlined function, NOT the function it was
-// inlined into.
+// Filter the symbol context list to remove contexts where the line number
+// was moved into a new function. We do this conservatively, so if e.g. we
+// cannot resolve the function in the context (which can happen in case of
+// line-table-only debug info), we leave the context as is. The trickiest
+// part here is handling inlined functions -- in this case we need to make
+// sure we look at the declaration line of the inlined function, NOT the
+// function it was inlined into.
 void BreakpointResolverFileLine::FilterContexts(SymbolContextList &sc_list,
                                                 bool is_relative) {
   if (m_exact_match)
@@ -129,8 +129,8 @@
     SymbolContext sc;
     sc_list.GetContextAtIndex(i, sc);
     if (is_relative) {
-      // If the path was relative, make sure any matches match as long as the
-      // relative parts of the path match the path from support files
+      // If the path was relative, make sure any matches match as long as
+      // the relative parts of the path match the path from support files
       auto sc_dir = sc.line_entry.file.GetDirectory().GetStringRef();
       if (!sc_dir.endswith(relative_path)) {
         // We had a relative path specified and the relative directory
@@ -173,9 +173,9 @@
     // {
     //   ...
     //
-    // the compiler will set the declaration line to the "foo" line, which is
-    // the reason why we have -1 here. This can fail in case of two inline
-    // functions defined back-to-back:
+    // the compiler will set the declaration line to the "foo" line, which
+    // is the reason why we have -1 here. This can fail in case of two
+    // inline functions defined back-to-back:
     //
     // inline int foo1() { ... }
     // inline int foo2() { ... }
@@ -199,20 +199,22 @@
   assert(m_breakpoint != NULL);
 
   // There is a tricky bit here.  You can have two compilation units that
-  // #include the same file, and in one of them the function at m_line_number is
-  // used (and so code and a line entry for it is generated) but in the other it
-  // isn't.  If we considered the CU's independently, then in the second
-  // inclusion, we'd move the breakpoint to the next function that actually
-  // generated code in the header file.  That would end up being confusing.  So
-  // instead, we do the CU iterations by hand here, then scan through the
-  // complete list of matches, and figure out the closest line number match, and
-  // only set breakpoints on that match.
-
-  // Note also that if file_spec only had a file name and not a directory, there
-  // may be many different file spec's in the resultant list.  The closest line
-  // match for one will not be right for some totally different file.  So we go
-  // through the match list and pull out the sets that have the same file spec
-  // in their line_entry and treat each set separately.
+  // #include the same file, and in one of them the function at
+  // m_line_number is used (and so code and a line entry for it is
+  // generated) but in the other it isn't.  If we considered the CU's
+  // independently, then in the second inclusion, we'd move the breakpoint
+  // to the next function that actually generated code in the header file.
+  // That would end up being confusing.  So instead, we do the CU
+  // iterations by hand here, then scan through the complete list of
+  // matches, and figure out the closest line number match, and only set
+  // breakpoints on that match.
+
+  // Note also that if file_spec only had a file name and not a directory,
+  // there may be many different file spec's in the resultant list.  The
+  // closest line match for one will not be right for some totally
+  // different file.  So we go through the match list and pull out the
+  // sets that have the same file spec in their line_entry and treat each
+  // set separately.
 
   FileSpec search_file_spec = m_file_spec;
   const bool is_relative = m_file_spec.IsRelative();
Index: source/Breakpoint/BreakpointResolverName.cpp
===================================================================
--- source/Breakpoint/BreakpointResolverName.cpp
+++ source/Breakpoint/BreakpointResolverName.cpp
@@ -239,11 +239,9 @@
 }
 
 // FIXME: Right now we look at the module level, and call the module's
-// "FindFunctions".
-// Greg says he will add function tables, maybe at the CompileUnit level to
-// accelerate function
-// lookup.  At that point, we should switch the depth to CompileUnit, and look
-// in these tables.
+// "FindFunctions". Greg says he will add function tables, maybe at the
+// CompileUnit level to accelerate function lookup.  At that point, we
+// should switch the depth to CompileUnit, and look in these tables.
 
 Searcher::CallbackReturn
 BreakpointResolverName::SearchCallback(SearchFilter &filter,
@@ -301,8 +299,8 @@
     break;
   }
 
-  // If the filter specifies a Compilation Unit, remove the ones that don't pass
-  // at this point.
+  // If the filter specifies a Compilation Unit, remove the ones that
+  // don't pass at this point.
   if (filter_by_cu || filter_by_language) {
     uint32_t num_functions = func_list.GetSize();
 
Index: source/Breakpoint/BreakpointSite.cpp
===================================================================
--- source/Breakpoint/BreakpointSite.cpp
+++ source/Breakpoint/BreakpointSite.cpp
@@ -49,8 +49,8 @@
   return ++g_next_id;
 }
 
-// RETURNS - true if we should stop at this breakpoint, false if we
-// should continue.
+// RETURNS - true if we should stop at this breakpoint, false if we should
+// continue.
 
 bool BreakpointSite::ShouldStop(StoppointCallbackContext *context) {
   std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
Index: source/Breakpoint/BreakpointSiteList.cpp
===================================================================
--- source/Breakpoint/BreakpointSiteList.cpp
+++ source/Breakpoint/BreakpointSiteList.cpp
@@ -23,9 +23,9 @@
 
 BreakpointSiteList::~BreakpointSiteList() {}
 
-// Add breakpoint site to the list.  However, if the element already exists in
-// the
-// list, then we don't add it, and return LLDB_INVALID_BREAK_ID.
+// Add breakpoint site to the list.  However, if the element already
+// exists in the list, then we don't add it, and return
+// LLDB_INVALID_BREAK_ID.
 
 lldb::break_id_t BreakpointSiteList::Add(const BreakpointSiteSP &bp) {
   lldb::addr_t bp_site_load_addr = bp->GetLoadAddress();
@@ -44,24 +44,25 @@
                                     lldb::break_id_t site_id) {
   BreakpointSiteSP site_sp(FindByID(site_id));
   if (site_sp) {
-    // Let the BreakpointSite decide if it should stop here (could not have
-    // reached it's target hit count yet, or it could have a callback
+    // Let the BreakpointSite decide if it should stop here (could not
+    // have reached it's target hit count yet, or it could have a callback
     // that decided it shouldn't stop (shared library loads/unloads).
     return site_sp->ShouldStop(context);
   }
-  // We should stop here since this BreakpointSite isn't valid anymore or it
-  // doesn't exist.
+  // We should stop here since this BreakpointSite isn't valid anymore or
+  // it doesn't exist.
   return true;
 }
 lldb::break_id_t BreakpointSiteList::FindIDByAddress(lldb::addr_t addr) {
   BreakpointSiteSP bp = FindByAddress(addr);
   if (bp) {
-    // DBLogIf(PD_LOG_BREAKPOINTS, "BreakpointSiteList::%s ( addr = 0x%8.8"
-    // PRIx64 " ) => %u", __FUNCTION__, (uint64_t)addr, bp->GetID());
+    // DBLogIf(PD_LOG_BREAKPOINTS, "BreakpointSiteList::%s ( addr =
+    // 0x%8.8" PRIx64 " ) => %u", __FUNCTION__, (uint64_t)addr,
+    // bp->GetID());
     return bp.get()->GetID();
   }
-  // DBLogIf(PD_LOG_BREAKPOINTS, "BreakpointSiteList::%s ( addr = 0x%8.8" PRIx64
-  // " ) => NONE", __FUNCTION__, (uint64_t)addr);
+  // DBLogIf(PD_LOG_BREAKPOINTS, "BreakpointSiteList::%s ( addr = 0x%8.8"
+  // PRIx64 " ) => NONE", __FUNCTION__, (uint64_t)addr);
   return LLDB_INVALID_BREAK_ID;
 }
 
@@ -185,10 +186,9 @@
   if (lower == m_bp_site_list.end() || (*lower).first >= upper_bound)
     return false;
 
-  // This is one tricky bit.  The breakpoint might overlap the bottom end of the
-  // range.  So we grab the
-  // breakpoint prior to the lower bound, and check that that + its byte size
-  // isn't in our range.
+  // This is one tricky bit.  The breakpoint might overlap the bottom end
+  // of the range.  So we grab the breakpoint prior to the lower bound,
+  // and check that that + its byte size isn't in our range.
   if (lower != m_bp_site_list.begin()) {
     collection::const_iterator prev_pos = lower;
     prev_pos--;
Index: source/Breakpoint/Watchpoint.cpp
===================================================================
--- source/Breakpoint/Watchpoint.cpp
+++ source/Breakpoint/Watchpoint.cpp
@@ -38,8 +38,8 @@
   if (type && type->IsValid())
     m_type = *type;
   else {
-    // If we don't have a known type, then we force it to unsigned int of the
-    // right size.
+    // If we don't have a known type, then we force it to unsigned int of
+    // the right size.
     ClangASTContext *ast_context = target.GetScratchClangASTContext();
     m_type = ast_context->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint,
                                                               8 * size);
@@ -89,8 +89,8 @@
   m_watch_spec_str = str;
 }
 
-// Override default impl of StoppointLocation::IsHardware() since m_is_hardware
-// member field is more accurate.
+// Override default impl of StoppointLocation::IsHardware() since
+// m_is_hardware member field is more accurate.
 bool Watchpoint::IsHardware() const { return m_is_hardware; }
 
 bool Watchpoint::IsWatchVariable() const { return m_is_watch_variable; }
@@ -103,10 +103,10 @@
   Address watch_address(GetLoadAddress());
   if (!m_type.IsValid()) {
     // Don't know how to report new & old values, since we couldn't make a
-    // scalar type for this watchpoint.
-    // This works around an assert in ValueObjectMemory::Create.
-    // FIXME: This should not happen, but if it does in some case we care about,
-    // we can go grab the value raw and print it as unsigned.
+    // scalar type for this watchpoint. This works around an assert in
+    // ValueObjectMemory::Create. FIXME: This should not happen, but if it
+    // does in some case we care about, we can go grab the value raw and
+    // print it as unsigned.
     return false;
   }
   m_new_value_sp = ValueObjectMemory::Create(
@@ -129,8 +129,8 @@
   }
 }
 
-// RETURNS - true if we should stop at this breakpoint, false if we
-// should continue.
+// RETURNS - true if we should stop at this breakpoint, false if we should
+// continue.
 
 bool Watchpoint::ShouldStop(StoppointCallbackContext *context) {
   IncrementHitCount();
@@ -216,11 +216,10 @@
 
 bool Watchpoint::IsEnabled() const { return m_enabled; }
 
-// Within StopInfo.cpp, we purposely turn on the ephemeral mode right before
-// temporarily disable the watchpoint
-// in order to perform possible watchpoint actions without triggering further
-// watchpoint events.
-// After the temporary disabled watchpoint is enabled, we then turn off the
+// Within StopInfo.cpp, we purposely turn on the ephemeral mode right
+// before temporarily disable the watchpoint in order to perform possible
+// watchpoint actions without triggering further watchpoint events. After
+// the temporary disabled watchpoint is enabled, we then turn off the
 // ephemeral mode.
 
 void Watchpoint::TurnOnEphemeralMode() { m_is_ephemeral = true; }
@@ -243,8 +242,8 @@
       ++m_disabled_count;
 
     // Don't clear the snapshots for now.
-    // Within StopInfo.cpp, we purposely do disable/enable watchpoint while
-    // performing watchpoint actions.
+    // Within StopInfo.cpp, we purposely do disable/enable watchpoint
+    // while performing watchpoint actions.
   }
   bool changed = enabled != m_enabled;
   m_enabled = enabled;
@@ -285,7 +284,8 @@
     if (m_condition_ap.get())
       m_condition_ap.reset();
   } else {
-    // Pass nullptr for expr_prefix (no translation-unit level definitions).
+    // Pass nullptr for expr_prefix (no translation-unit level
+    // definitions).
     Status error;
     m_condition_ap.reset(m_target.GetUserExpressionForLanguage(
         condition, llvm::StringRef(), lldb::eLanguageTypeUnknown,
Index: source/Breakpoint/WatchpointList.cpp
===================================================================
--- source/Breakpoint/WatchpointList.cpp
+++ source/Breakpoint/WatchpointList.cpp
@@ -204,8 +204,8 @@
   WatchpointSP wp_sp = FindByID(watch_id);
   if (wp_sp) {
     // Let the Watchpoint decide if it should stop here (could not have
-    // reached it's target hit count yet, or it could have a callback
-    // that decided it shouldn't stop.
+    // reached it's target hit count yet, or it could have a callback that
+    // decided it shouldn't stop.
     return wp_sp->ShouldStop(context);
   }
   // We should stop here since this Watchpoint isn't valid anymore or it
Index: source/Breakpoint/WatchpointOptions.cpp
===================================================================
--- source/Breakpoint/WatchpointOptions.cpp
+++ source/Breakpoint/WatchpointOptions.cpp
@@ -142,9 +142,8 @@
 
 void WatchpointOptions::GetDescription(Stream *s,
                                        lldb::DescriptionLevel level) const {
-  // Figure out if there are any options not at their default value, and only
-  // print
-  // anything if there are:
+  // Figure out if there are any options not at their default value, and
+  // only print anything if there are:
 
   if ((GetThreadSpecNoCreate() != nullptr &&
        GetThreadSpecNoCreate()->HasSpecification())) {
Index: source/Commands/CommandCompletions.cpp
===================================================================
--- source/Commands/CommandCompletions.cpp
+++ source/Commands/CommandCompletions.cpp
@@ -133,9 +133,10 @@
 
     llvm::SmallString<PATH_MAX> Resolved;
     if (!Resolver.ResolveExact(Username, Resolved)) {
-      // We couldn't resolve it as a full username.  If there were no slashes
-      // then this might be a partial username.   We try to resolve it as such
-      // but after that, we're done regardless of any matches.
+      // We couldn't resolve it as a full username.  If there were no
+      // slashes then this might be a partial username.   We try to
+      // resolve it as such but after that, we're done regardless of any
+      // matches.
       if (FirstSep == llvm::StringRef::npos) {
         llvm::StringSet<> MatchSet;
         saw_directory = Resolver.ResolvePartial(Username, MatchSet);
@@ -149,9 +150,9 @@
       return matches.GetSize();
     }
 
-    // If there was no trailing slash, then we're done as soon as we resolve the
-    // expression to the correct directory.  Otherwise we need to continue
-    // looking for matches within that directory.
+    // If there was no trailing slash, then we're done as soon as we
+    // resolve the expression to the correct directory.  Otherwise we need
+    // to continue looking for matches within that directory.
     if (FirstSep == llvm::StringRef::npos) {
       // Make sure it ends with a separator.
       path::append(CompletionBuffer, path::get_separator());
@@ -161,8 +162,8 @@
     }
 
     // We want to keep the form the user typed, so we special case this to
-    // search in the fully resolved directory, but CompletionBuffer keeps the
-    // unmodified form that the user typed.
+    // search in the fully resolved directory, but CompletionBuffer keeps
+    // the unmodified form that the user typed.
     Storage = Resolved;
     SearchDir = Storage;
   } else {
@@ -181,8 +182,8 @@
   }
   assert(!PartialItem.contains(path::get_separator()));
 
-  // SearchDir now contains the directory to search in, and Prefix contains the
-  // text we want to match against items in that directory.
+  // SearchDir now contains the directory to search in, and Prefix
+  // contains the text we want to match against items in that directory.
 
   std::error_code EC;
   fs::directory_iterator Iter(SearchDir, EC, false);
@@ -202,8 +203,8 @@
     if (!st)
       continue;
 
-    // If it's a symlink, then we treat it as a directory as long as the target
-    // is a directory.
+    // If it's a symlink, then we treat it as a directory as long as the
+    // target is a directory.
     bool is_dir = fs::is_directory(*st);
     if (fs::is_symlink_file(*st)) {
       fs::file_status target_st;
@@ -213,9 +214,9 @@
     if (only_directories && !is_dir)
       continue;
 
-    // Shrink it back down so that it just has the original prefix the user
-    // typed and remove the part of the name which is common to the located
-    // item and what the user typed.
+    // Shrink it back down so that it just has the original prefix the
+    // user typed and remove the part of the name which is common to the
+    // located item and what the user typed.
     CompletionBuffer.resize(FullPrefixLen);
     Name = Name.drop_front(PartialItem.size());
     CompletionBuffer.append(Name);
Index: source/Commands/CommandObjectApropos.cpp
===================================================================
--- source/Commands/CommandObjectApropos.cpp
+++ source/Commands/CommandObjectApropos.cpp
@@ -37,8 +37,8 @@
   search_word_arg.arg_type = eArgTypeSearchWord;
   search_word_arg.arg_repetition = eArgRepeatPlain;
 
-  // There is only one variant this argument could be; put it into the argument
-  // entry.
+  // There is only one variant this argument could be; put it into the
+  // argument entry.
   arg.push_back(search_word_arg);
 
   // Push the data for the first argument into the m_arguments vector.
@@ -53,8 +53,8 @@
   if (argc == 1) {
     auto search_word = args[0].ref;
     if (!search_word.empty()) {
-      // The bulk of the work must be done inside the Command Interpreter, since
-      // the command dictionary is private.
+      // The bulk of the work must be done inside the Command Interpreter,
+      // since the command dictionary is private.
       StringList commands_found;
       StringList commands_help;
 
Index: source/Commands/CommandObjectBreakpoint.cpp
===================================================================
--- source/Commands/CommandObjectBreakpoint.cpp
+++ source/Commands/CommandObjectBreakpoint.cpp
@@ -85,8 +85,8 @@
 
     switch (short_option) {
     case 'c':
-      // Normally an empty breakpoint condition marks is as unset.
-      // But we need to say it was passed in.
+      // Normally an empty breakpoint condition marks is as unset. But we
+      // need to say it was passed in.
       m_bp_opts.SetCondition(option_arg.str().c_str());
       m_bp_opts.m_set_flags.Set(BreakpointOptions::eCondition);
       break;
@@ -243,8 +243,9 @@
 
 };
 
-// If an additional option set beyond LLDB_OPTION_SET_10 is added, make sure to
-// update the numbers passed to LLDB_OPT_SET_FROM_TO(...) appropriately.
+// If an additional option set beyond LLDB_OPTION_SET_10 is added, make
+// sure to update the numbers passed to LLDB_OPT_SET_FROM_TO(...)
+// appropriately.
 #define LLDB_OPT_FILE (LLDB_OPT_SET_FROM_TO(1, 9) & ~LLDB_OPT_SET_2)
 #define LLDB_OPT_NOT_10 (LLDB_OPT_SET_FROM_TO(1, 10) & ~LLDB_OPT_SET_10)
 #define LLDB_OPT_SKIP_PROLOGUE (LLDB_OPT_SET_1 | LLDB_OPT_SET_FROM_TO(3, 8))
@@ -263,8 +264,9 @@
   "#included, set target.inline-breakpoint-strategy to \"always\"." },
   { LLDB_OPT_SET_1,                true,  "line",                   'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLineNum,             "Specifies the line number on which to set this breakpoint." },
 
-  // Comment out this option for the moment, as we don't actually use it, but will in the future.
-  // This way users won't see it, but the infrastructure is left in place.
+  // Comment out this option for the moment, as we don't actually use it,
+  // but will in the future. This way users won't see it, but the
+  // infrastructure is left in place.
   //    { 0, false, "column",     'C', OptionParser::eRequiredArgument, nullptr, "<column>",
   //    "Set the breakpoint by source location at this particular column."},
 
@@ -344,7 +346,8 @@
             "Sets a breakpoint or set of breakpoints in the executable.",
             "breakpoint set <cmd-options>"),
         m_bp_opts(), m_options() {
-          // We're picking up all the normal options, commands and disable.
+          // We're picking up all the normal options, commands and
+          // disable.
           m_all_options.Append(&m_bp_opts, 
                                LLDB_OPT_SET_1 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4, 
                                LLDB_OPT_SET_ALL);
@@ -635,7 +638,8 @@
       return false;
     }
 
-    // The following are the various types of breakpoints that could be set:
+    // The following are the various types of breakpoints that could be
+    // set:
     //   1).  -f -l -p  [-s -g]   (setting breakpoint by source location)
     //   2).  -a  [-s -g]         (setting breakpoint by address)
     //   3).  -n  [-s -g]         (setting breakpoint by function name)
@@ -665,8 +669,8 @@
     FileSpec module_spec;
     const bool internal = false;
 
-    // If the user didn't specify skip-prologue, having an offset should turn
-    // that off.
+    // If the user didn't specify skip-prologue, having an offset should
+    // turn that off.
     if (m_options.m_offset_addr != 0 &&
         m_options.m_skip_prologue == eLazyBoolCalculate)
       m_options.m_skip_prologue = eLazyBoolNo;
@@ -706,8 +710,9 @@
 
     case eSetTypeAddress: // Breakpoint by address
     {
-      // If a shared library has been specified, make an lldb_private::Address
-      // with the library, and use that.  That way the address breakpoint
+      // If a shared library has been specified, make an
+      // lldb_private::Address with the library, and use that.  That way
+      // the address breakpoint
       //  will track the load location of the library.
       size_t num_modules_specified = m_options.m_modules.GetSize();
       if (num_modules_specified == 1) {
@@ -854,9 +859,9 @@
         output_stream.Printf("Breakpoint set in dummy target, will get copied "
                              "into future targets.\n");
       else {
-        // Don't print out this warning for exception breakpoints.  They can get
-        // set before the target is set, but we won't know how to actually set
-        // the breakpoint till we run.
+        // Don't print out this warning for exception breakpoints.  They
+        // can get set before the target is set, but we won't know how to
+        // actually set the breakpoint till we run.
         if (bp_sp->GetNumLocations() == 0 && break_type != eSetTypeException) {
           output_stream.Printf("WARNING:  Unable to resolve breakpoint to any "
                                "actual locations.\n");
@@ -875,8 +880,8 @@
   bool GetDefaultFile(Target *target, FileSpec &file,
                       CommandReturnObject &result) {
     uint32_t default_line;
-    // First use the Source Manager's default file.
-    // Then use the current stack frame's file.
+    // First use the Source Manager's default file. Then use the current
+    // stack frame's file.
     if (!target->GetSourceManager().GetDefaultFileAndLine(file, default_line)) {
       StackFrame *cur_frame = m_exe_ctx.GetFramePtr();
       if (cur_frame == nullptr) {
@@ -931,8 +936,8 @@
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID,
                                       eArgTypeBreakpointIDRange);
-    // Add the entry for the first argument for this command to the object's
-    // arguments vector.
+    // Add the entry for the first argument for this command to the
+    // object's arguments vector.
     m_arguments.push_back(arg);
     
     m_options.Append(&m_bp_opts, 
@@ -1010,8 +1015,8 @@
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID,
                                       eArgTypeBreakpointIDRange);
-    // Add the entry for the first argument for this command to the object's
-    // arguments vector.
+    // Add the entry for the first argument for this command to the
+    // object's arguments vector.
     m_arguments.push_back(arg);
   }
 
@@ -1125,8 +1130,8 @@
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID,
                                       eArgTypeBreakpointIDRange);
-    // Add the entry for the first argument for this command to the object's
-    // arguments vector.
+    // Add the entry for the first argument for this command to the
+    // object's arguments vector.
     m_arguments.push_back(arg);
   }
 
@@ -1210,8 +1215,8 @@
     // clang-format off
   { LLDB_OPT_SET_ALL, false, "internal",          'i', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Show debugger internal breakpoints" },
   { LLDB_OPT_SET_1,   false, "brief",             'b', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Give a brief description of the breakpoint (no location info)." },
-  // FIXME: We need to add an "internal" command, and then add this sort of thing to it.
-  // But I need to see it for now, and don't want to wait.
+  // FIXME: We need to add an "internal" command, and then add this sort
+  // of thing to it. But I need to see it for now, and don't want to wait.
   { LLDB_OPT_SET_2,   false, "full",              'f', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Give a full description of the breakpoint and its locations." },
   { LLDB_OPT_SET_3,   false, "verbose",           'v', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Explain everything we know about the breakpoint (for debugging debugger bugs)." },
   { LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "List Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets." },
@@ -1329,7 +1334,8 @@
     Stream &output_stream = result.GetOutputStream();
 
     if (command.empty()) {
-      // No breakpoint selected; show info about all currently set breakpoints.
+      // No breakpoint selected; show info about all currently set
+      // breakpoints.
       result.AppendMessage("Current breakpoints:");
       for (size_t i = 0; i < num_breakpoints; ++i) {
         Breakpoint *breakpoint = breakpoints.GetBreakpointAtIndex(i).get();
@@ -1452,7 +1458,8 @@
       return false;
     }
 
-    // The following are the various types of breakpoints that could be cleared:
+    // The following are the various types of breakpoints that could be
+    // cleared:
     //   1). -f -l (clearing breakpoint by source location)
 
     BreakpointClearType break_type = eClearTypeInvalid;
@@ -1492,8 +1499,8 @@
         Breakpoint *bp = breakpoints.FindBreakpointByID(BreakIDs[i]).get();
 
         if (bp->GetMatchingFileLine(filename, m_options.m_line_num, loc_coll)) {
-          // If the collection size is 0, it's a full match and we can just
-          // remove the breakpoint.
+          // If the collection size is 0, it's a full match and we can
+          // just remove the breakpoint.
           if (loc_coll.GetSize() == 0) {
             bp->GetDescription(&ss, lldb::eDescriptionLevelBrief);
             ss.EOL();
@@ -1549,8 +1556,8 @@
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID,
                                       eArgTypeBreakpointIDRange);
-    // Add the entry for the first argument for this command to the object's
-    // arguments vector.
+    // Add the entry for the first argument for this command to the
+    // object's arguments vector.
     m_arguments.push_back(arg);
   }
 
@@ -1657,8 +1664,8 @@
                   target->GetBreakpointByID(cur_bp_id.GetBreakpointID()).get();
               BreakpointLocation *location =
                   breakpoint->FindLocationByID(cur_bp_id.GetLocationID()).get();
-              // It makes no sense to try to delete individual locations, so we
-              // disable them instead.
+              // It makes no sense to try to delete individual locations,
+              // so we disable them instead.
               if (location) {
                 location->SetEnabled(false);
                 ++disable_count;
@@ -1898,8 +1905,8 @@
         return false;
       }
     }
-    // Now configure them, we already pre-checked the names so we don't need
-    // to check the error:
+    // Now configure them, we already pre-checked the names so we don't
+    // need to check the error:
     BreakpointSP bp_sp;
     if (m_bp_id.m_breakpoint.OptionWasSet())
     {
@@ -2009,7 +2016,8 @@
       size_t num_valid_ids = valid_bp_ids.GetSize();
       const char *bp_name = m_name_options.m_name.GetCurrentValue();
       Status error; // This error reports illegal names, but we've already 
-                    // checked that, so we don't need to check it again here.
+                    // checked that, so we don't need to check it again
+                    // here.
       for (size_t index = 0; index < num_valid_ids; index++) {
         lldb::break_id_t bp_id =
             valid_bp_ids.GetBreakpointIDAtIndex(index).GetBreakpointID();
@@ -2247,8 +2255,8 @@
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID,
                                       eArgTypeBreakpointIDRange);
-    // Add the entry for the first argument for this command to the object's
-    // arguments vector.
+    // Add the entry for the first argument for this command to the
+    // object's arguments vector.
     m_arguments.push_back(arg);
   }
 
@@ -2334,7 +2342,8 @@
     if (num_breakpoints == 0) {
       result.AppendMessage("No breakpoints added.");
     } else {
-      // No breakpoint selected; show info about all currently set breakpoints.
+      // No breakpoint selected; show info about all currently set
+      // breakpoints.
       result.AppendMessage("New breakpoints:");
       for (size_t i = 0; i < num_breakpoints; ++i) {
         BreakpointID bp_id = new_bps.GetBreakpointIDAtIndex(i);
@@ -2377,8 +2386,8 @@
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID,
                                       eArgTypeBreakpointIDRange);
-    // Add the entry for the first argument for this command to the object's
-    // arguments vector.
+    // Add the entry for the first argument for this command to the
+    // object's arguments vector.
     m_arguments.push_back(arg);
   }
 
@@ -2541,8 +2550,8 @@
   //                                      had *better* be an entry both before &
   //                                      after of one of the first two types.
   //                                  4). A breakpoint name
-  // If args is empty, we will use the last created breakpoint (if there is
-  // one.)
+  // If args is empty, we will use the last created breakpoint (if there
+  // is one.)
 
   Args temp_args;
 
@@ -2559,31 +2568,28 @@
     return;
   }
 
-  // Create a new Args variable to use; copy any non-breakpoint-id-ranges stuff
-  // directly from the old ARGS to
-  // the new TEMP_ARGS.  Do not copy breakpoint id range strings over; instead
-  // generate a list of strings for
-  // all the breakpoint ids in the range, and shove all of those breakpoint id
-  // strings into TEMP_ARGS.
+  // Create a new Args variable to use; copy any non-breakpoint-id-ranges
+  // stuff directly from the old ARGS to the new TEMP_ARGS.  Do not copy
+  // breakpoint id range strings over; instead generate a list of strings
+  // for all the breakpoint ids in the range, and shove all of those
+  // breakpoint id strings into TEMP_ARGS.
 
   BreakpointIDList::FindAndReplaceIDRanges(args, target, allow_locations, 
                                            purpose, result, temp_args);
 
-  // NOW, convert the list of breakpoint id strings in TEMP_ARGS into an actual
-  // BreakpointIDList:
+  // NOW, convert the list of breakpoint id strings in TEMP_ARGS into an
+  // actual BreakpointIDList:
 
   valid_ids->InsertStringArray(temp_args.GetConstArgumentVector(),
                                temp_args.GetArgumentCount(), result);
 
-  // At this point,  all of the breakpoint ids that the user passed in have been
-  // converted to breakpoint IDs
-  // and put into valid_ids.
+  // At this point,  all of the breakpoint ids that the user passed in
+  // have been converted to breakpoint IDs and put into valid_ids.
 
   if (result.Succeeded()) {
-    // Now that we've converted everything from args into a list of breakpoint
-    // ids, go through our tentative list
-    // of breakpoint id's and verify that they correspond to valid/currently set
-    // breakpoints.
+    // Now that we've converted everything from args into a list of
+    // breakpoint ids, go through our tentative list of breakpoint id's
+    // and verify that they correspond to valid/currently set breakpoints.
 
     const size_t count = valid_ids->GetSize();
     for (size_t i = 0; i < count; ++i) {
Index: source/Commands/CommandObjectBreakpointCommand.cpp
===================================================================
--- source/Commands/CommandObjectBreakpointCommand.cpp
+++ source/Commands/CommandObjectBreakpointCommand.cpp
@@ -35,10 +35,10 @@
 // CommandObjectBreakpointCommandAdd
 //-------------------------------------------------------------------------
 
-// FIXME: "script-type" needs to have its contents determined dynamically, so
-// somebody can add a new scripting
-// language to lldb and have it pickable here without having to change this
-// enumeration by hand and rebuild lldb proper.
+// FIXME: "script-type" needs to have its contents determined dynamically,
+// so somebody can add a new scripting language to lldb and have it
+// pickable here without having to change this enumeration by hand and
+// rebuild lldb proper.
 
 static OptionEnumValueElement g_script_option_enumeration[4] = {
     {eScriptLanguageNone, "command",
@@ -412,8 +412,8 @@
           } else {
             BreakpointLocationSP bp_loc_sp(
                 bp->FindLocationByID(cur_bp_id.GetLocationID()));
-            // This breakpoint does have an associated location.
-            // Get its breakpoint options.
+            // This breakpoint does have an associated location. Get its
+            // breakpoint options.
             if (bp_loc_sp)
               bp_options = bp_loc_sp->GetLocationOptions();
           }
@@ -422,9 +422,9 @@
         }
       }
 
-      // If we are using script language, get the script interpreter
-      // in order to set or collect command callback.  Otherwise, call
-      // the methods associated with this object.
+      // If we are using script language, get the script interpreter in
+      // order to set or collect command callback.  Otherwise, call the
+      // methods associated with this object.
       if (m_options.m_use_script_language) {
         ScriptInterpreter *script_interp = m_interpreter.GetScriptInterpreter();
         // Special handling for one-liner specified inline.
@@ -456,16 +456,15 @@
   std::vector<BreakpointOptions *> m_bp_options_vec; // This stores the
                                                      // breakpoint options that
                                                      // we are currently
-  // collecting commands for.  In the CollectData... calls we need
-  // to hand this off to the IOHandler, which may run asynchronously.
-  // So we have to have some way to keep it alive, and not leak it.
-  // Making it an ivar of the command object, which never goes away
-  // achieves this.  Note that if we were able to run
-  // the same command concurrently in one interpreter we'd have to
-  // make this "per invocation".  But there are many more reasons
-  // why it is not in general safe to do that in lldb at present,
-  // so it isn't worthwhile to come up with a more complex mechanism
-  // to address this particular weakness right now.
+  // collecting commands for.  In the CollectData... calls we need to hand
+  // this off to the IOHandler, which may run asynchronously. So we have
+  // to have some way to keep it alive, and not leak it. Making it an ivar
+  // of the command object, which never goes away achieves this.  Note
+  // that if we were able to run the same command concurrently in one
+  // interpreter we'd have to make this "per invocation".  But there are
+  // many more reasons why it is not in general safe to do that in lldb at
+  // present, so it isn't worthwhile to come up with a more complex
+  // mechanism to address this particular weakness right now.
   static const char *g_reader_instructions;
 };
 
Index: source/Commands/CommandObjectCommands.cpp
===================================================================
--- source/Commands/CommandObjectCommands.cpp
+++ source/Commands/CommandObjectCommands.cpp
@@ -332,8 +332,7 @@
       m_interpreter.HandleCommandsFromFile(cmd_file, exe_ctx, options, result);
     } else {
       // No options were set, inherit any settings from nested "command
-      // source" commands,
-      // or set to sane default settings...
+      // source" commands, or set to sane default settings...
       CommandInterpreterRunOptions options;
       m_interpreter.HandleCommandsFromFile(cmd_file, exe_ctx, options, result);
     }
@@ -613,9 +612,9 @@
       return false;
     }
 
-    // Strip the new alias name off 'raw_command_string'  (leave it on args,
-    // which gets passed to 'Execute', which
-    // does the stripping itself.
+    // Strip the new alias name off 'raw_command_string'  (leave it on
+    // args, which gets passed to 'Execute', which does the stripping
+    // itself.
     size_t pos = raw_command_string.find(alias_command);
     if (pos == 0) {
       raw_command_string = raw_command_string.substr(alias_command.size());
@@ -637,9 +636,10 @@
       return false;
     }
 
-    // Get CommandObject that is being aliased. The command name is read from
-    // the front of raw_command_string. raw_command_string is returned with the
-    // name of the command object stripped off the front.
+    // Get CommandObject that is being aliased. The command name is read
+    // from the front of raw_command_string. raw_command_string is
+    // returned with the name of the command object stripped off the
+    // front.
     llvm::StringRef original_raw_command_string = raw_command_string;
     CommandObject *cmd_obj =
         m_interpreter.GetCommandObjectForCommand(raw_command_string);
@@ -652,10 +652,10 @@
       result.SetStatus(eReturnStatusFailed);
       return false;
     } else if (!cmd_obj->WantsRawCommandString()) {
-      // Note that args was initialized with the original command, and has not
-      // been updated to this point.
-      // Therefore can we pass it to the version of Execute that does not
-      // need/expect raw input in the alias.
+      // Note that args was initialized with the original command, and has
+      // not been updated to this point. Therefore can we pass it to the
+      // version of Execute that does not need/expect raw input in the
+      // alias.
       return HandleAliasingNormalCommand(args, result);
     } else {
       return HandleAliasingRawCommand(alias_command, raw_command_string,
@@ -717,8 +717,8 @@
     args.Shift(); // Shift the alias command word off the argument vector.
     args.Shift(); // Shift the old command word off the argument vector.
 
-    // Verify that the command is alias'able, and get the appropriate command
-    // object.
+    // Verify that the command is alias'able, and get the appropriate
+    // command object.
 
     if (m_interpreter.CommandExists(alias_command)) {
       result.AppendErrorWithFormat(
@@ -1129,8 +1129,8 @@
       return error;
     }
     const size_t first_separator_char_pos = 1;
-    // use the char that follows 's' as the regex separator character
-    // so we can have "s/<regex>/<subst>/" or "s|<regex>|<subst>|"
+    // use the char that follows 's' as the regex separator character so
+    // we can have "s/<regex>/<subst>/" or "s|<regex>|<subst>|"
     const char separator_char = regex_sed[first_separator_char_pos];
     const size_t second_separator_char_pos =
         regex_sed.find(separator_char, first_separator_char_pos + 1);
@@ -1159,8 +1159,8 @@
     }
 
     if (third_separator_char_pos != regex_sed_size - 1) {
-      // Make sure that everything that follows the last regex
-      // separator char
+      // Make sure that everything that follows the last regex separator
+      // char
       if (regex_sed.find_first_not_of("\t\n\v\f\r ",
                                       third_separator_char_pos + 1) !=
           std::string::npos) {
@@ -1538,13 +1538,15 @@
       Status error;
 
       const bool init_session = true;
-      // FIXME: this is necessary because CommandObject::CheckRequirements()
-      // assumes that commands won't ever be recursively invoked, but it's
-      // actually possible to craft a Python script that does other "command
-      // script imports" in __lldb_init_module the real fix is to have recursive
-      // commands possible with a CommandInvocation object separate from the
-      // CommandObject itself, so that recursive command invocations won't stomp
-      // on each other (wrt to execution contents, options, and more)
+      // FIXME: this is necessary because
+      // CommandObject::CheckRequirements() assumes that commands won't
+      // ever be recursively invoked, but it's actually possible to craft
+      // a Python script that does other "command script imports" in
+      // __lldb_init_module the real fix is to have recursive commands
+      // possible with a CommandInvocation object separate from the
+      // CommandObject itself, so that recursive command invocations won't
+      // stomp on each other (wrt to execution contents, options, and
+      // more)
       m_exe_ctx.Clear();
       if (m_interpreter.GetScriptInterpreter()->LoadScriptingModule(
               entry.c_str(), m_options.m_allow_reload, init_session, error)) {
Index: source/Commands/CommandObjectDisassemble.cpp
===================================================================
--- source/Commands/CommandObjectDisassemble.cpp
+++ source/Commands/CommandObjectDisassemble.cpp
@@ -205,10 +205,9 @@
       execution_context ? execution_context->GetTargetPtr() : nullptr;
 
   // This is a hack till we get the ability to specify features based on
-  // architecture.  For now GetDisassemblyFlavor
-  // is really only valid for x86 (and for the llvm assembler plugin, but I'm
-  // papering over that since that is the
-  // only disassembler plugin we have...
+  // architecture.  For now GetDisassemblyFlavor is really only valid for
+  // x86 (and for the llvm assembler plugin, but I'm papering over that
+  // since that is the only disassembler plugin we have...
   if (target) {
     if (target->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86 ||
         target->GetArchitecture().GetTriple().getArch() ==
@@ -314,8 +313,8 @@
   // Always show the PC in the disassembly
   uint32_t options = Disassembler::eOptionMarkPCAddress;
 
-  // Mark the source line for the current PC only if we are doing mixed source
-  // and assembly
+  // Mark the source line for the current PC only if we are doing mixed
+  // source and assembly
   if (m_options.show_mixed)
     options |= Disassembler::eOptionMarkPCSourceLine;
 
@@ -470,7 +469,8 @@
 
     if (m_options.num_instructions != 0) {
       if (ranges.empty()) {
-        // The default action is to disassemble the current frame function.
+        // The default action is to disassemble the current frame
+        // function.
         if (frame) {
           SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction |
                                                    eSymbolContextSymbol));
@@ -516,7 +516,8 @@
         result.AppendMessage("\n");
     } else {
       if (ranges.empty()) {
-        // The default action is to disassemble the current frame function.
+        // The default action is to disassemble the current frame
+        // function.
         if (frame) {
           SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction |
                                                    eSymbolContextSymbol));
Index: source/Commands/CommandObjectExpression.cpp
===================================================================
--- source/Commands/CommandObjectExpression.cpp
+++ source/Commands/CommandObjectExpression.cpp
@@ -284,8 +284,8 @@
   expression_arg.arg_type = eArgTypeExpression;
   expression_arg.arg_repetition = eArgRepeatPlain;
 
-  // There is only one variant this argument could be; put it into the argument
-  // entry.
+  // There is only one variant this argument could be; put it into the
+  // argument entry.
   arg.push_back(expression_arg);
 
   // Push the data for the first argument into the m_arguments vector.
@@ -322,9 +322,9 @@
                                                  Stream *output_stream,
                                                  Stream *error_stream,
                                                  CommandReturnObject *result) {
-  // Don't use m_exe_ctx as this might be called asynchronously
-  // after the command object DoExecute has finished when doing
-  // multi-line expression that use an input reader...
+  // Don't use m_exe_ctx as this might be called asynchronously after the
+  // command object DoExecute has finished when doing multi-line
+  // expression that use an input reader...
   ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
 
   Target *target = exe_ctx.GetTargetPtr();
@@ -363,8 +363,8 @@
     if (m_command_options.top_level)
       options.SetExecutionPolicy(eExecutionPolicyTopLevel);
 
-    // If there is any chance we are going to stop and want to see
-    // what went wrong with our expression, we should generate debug info
+    // If there is any chance we are going to stop and want to see what
+    // went wrong with our expression, we should generate debug info
     if (!m_command_options.ignore_breakpoints ||
         !m_command_options.unwind_on_error)
       options.SetGenerateDebugInfo(true);
@@ -377,8 +377,8 @@
     ExpressionResults success = target->EvaluateExpression(
         expr, frame, result_valobj_sp, options, &m_fixed_expression);
 
-    // We only tell you about the FixIt if we applied it.  The compiler errors
-    // will suggest the FixIt if it parsed.
+    // We only tell you about the FixIt if we applied it.  The compiler
+    // errors will suggest the FixIt if it parsed.
     if (error_stream && !m_fixed_expression.empty() &&
         target->GetEnableNotifyAboutFixIts()) {
       if (success == eExpressionCompleted)
@@ -475,9 +475,9 @@
   // An empty lines is used to indicate the end of input
   const size_t num_lines = lines.GetSize();
   if (num_lines > 0 && lines[num_lines - 1].empty()) {
-    // Remove the last empty line from "lines" so it doesn't appear
-    // in our resulting input and return true to indicate we are done
-    // getting lines
+    // Remove the last empty line from "lines" so it doesn't appear in our
+    // resulting input and return true to indicate we are done getting
+    // lines
     lines.PopBack();
     return true;
   }
@@ -561,20 +561,17 @@
 
           Debugger &debugger = target->GetDebugger();
 
-          // Check if the LLDB command interpreter is sitting on top of a REPL
-          // that
-          // launched it...
+          // Check if the LLDB command interpreter is sitting on top of a
+          // REPL that launched it...
           if (debugger.CheckTopIOHandlerTypes(
                   IOHandler::Type::CommandInterpreter, IOHandler::Type::REPL)) {
-            // the LLDB command interpreter is sitting on top of a REPL that
-            // launched it,
-            // so just say the command interpreter is done and fall back to the
-            // existing REPL
+            // the LLDB command interpreter is sitting on top of a REPL
+            // that launched it, so just say the command interpreter is
+            // done and fall back to the existing REPL
             m_interpreter.GetIOHandler(false)->SetIsDone(true);
           } else {
-            // We are launching the REPL on top of the current LLDB command
-            // interpreter,
-            // so just push one
+            // We are launching the REPL on top of the current LLDB
+            // command interpreter, so just push one
             bool initialize = false;
             Status repl_error;
             REPLSP repl_sp(target->GetREPL(
@@ -629,27 +626,25 @@
 
     if (!m_fixed_expression.empty() && target->GetEnableNotifyAboutFixIts()) {
       CommandHistory &history = m_interpreter.GetCommandHistory();
-      // FIXME: Can we figure out what the user actually typed (e.g. some alias
-      // for expr???)
-      // If we can it would be nice to show that.
+      // FIXME: Can we figure out what the user actually typed (e.g. some
+      // alias for expr???) If we can it would be nice to show that.
       std::string fixed_command("expression ");
       if (expr == command)
         fixed_command.append(m_fixed_expression);
       else {
-        // Add in any options that might have been in the original command:
+        // Add in any options that might have been in the original
+        // command:
         fixed_command.append(command, expr - command);
         fixed_command.append(m_fixed_expression);
       }
       history.AppendString(fixed_command);
     }
-    // Increment statistics to record this expression evaluation
-    // success.
+    // Increment statistics to record this expression evaluation success.
     target->IncrementStats(StatisticKind::ExpressionSuccessful);
     return true;
   }
 
-  // Increment statistics to record this expression evaluation
-  // failure.
+  // Increment statistics to record this expression evaluation failure.
   target->IncrementStats(StatisticKind::ExpressionFailure);
   result.SetStatus(eReturnStatusFailed);
   return false;
Index: source/Commands/CommandObjectFrame.cpp
===================================================================
--- source/Commands/CommandObjectFrame.cpp
+++ source/Commands/CommandObjectFrame.cpp
@@ -326,8 +326,8 @@
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    // No need to check "thread" for validity as eCommandRequiresThread ensures
-    // it is valid
+    // No need to check "thread" for validity as eCommandRequiresThread
+    // ensures it is valid
     Thread *thread = m_exe_ctx.GetThreadPtr();
 
     uint32_t frame_idx = UINT32_MAX;
@@ -342,8 +342,8 @@
           frame_idx += m_options.relative_frame_offset;
         else {
           if (frame_idx == 0) {
-            // If you are already at the bottom of the stack, then just warn and
-            // don't reset the frame.
+            // If you are already at the bottom of the stack, then just
+            // warn and don't reset the frame.
             result.AppendError("Already at the bottom of the stack.");
             result.SetStatus(eReturnStatusFailed);
             return false;
@@ -351,18 +351,17 @@
             frame_idx = 0;
         }
       } else if (m_options.relative_frame_offset > 0) {
-        // I don't want "up 20" where "20" takes you past the top of the stack
-        // to produce
-        // an error, but rather to just go to the top.  So I have to count the
-        // stack here...
+        // I don't want "up 20" where "20" takes you past the top of the
+        // stack to produce an error, but rather to just go to the top.
+        // So I have to count the stack here...
         const uint32_t num_frames = thread->GetStackFrameCount();
         if (static_cast<int32_t>(num_frames - frame_idx) >
             m_options.relative_frame_offset)
           frame_idx += m_options.relative_frame_offset;
         else {
           if (frame_idx == num_frames - 1) {
-            // If we are already at the top of the stack, just warn and don't
-            // reset the frame.
+            // If we are already at the top of the stack, just warn and
+            // don't reset the frame.
             result.AppendError("Already at the top of the stack.");
             result.SetStatus(eReturnStatusFailed);
             return false;
@@ -504,16 +503,15 @@
   }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    // No need to check "frame" for validity as eCommandRequiresFrame ensures it
-    // is valid
+    // No need to check "frame" for validity as eCommandRequiresFrame
+    // ensures it is valid
     StackFrame *frame = m_exe_ctx.GetFramePtr();
 
     Stream &s = result.GetOutputStream();
 
-    // Be careful about the stack frame, if any summary formatter runs code, it
-    // might clear the StackFrameList
-    // for the thread.  So hold onto a shared pointer to the frame so it stays
-    // alive.
+    // Be careful about the stack frame, if any summary formatter runs
+    // code, it might clear the StackFrameList for the thread.  So hold
+    // onto a shared pointer to the frame so it stays alive.
 
     VariableList *variable_list =
         frame->GetVariableList(m_option_variable.show_globals);
@@ -677,9 +675,8 @@
             if (m_option_variable.show_scope)
               scope_string = GetScopeString(var_sp).str();
 
-            // Use the variable object code to make sure we are
-            // using the same APIs as the public API will be
-            // using...
+            // Use the variable object code to make sure we are using the
+            // same APIs as the public API will be using...
             valobj_sp = frame->GetValueObjectForFrameVariable(
                 var_sp, m_varobj_options.use_dynamic);
             if (valobj_sp) {
Index: source/Commands/CommandObjectHelp.cpp
===================================================================
--- source/Commands/CommandObjectHelp.cpp
+++ source/Commands/CommandObjectHelp.cpp
@@ -61,8 +61,8 @@
   command_arg.arg_type = eArgTypeCommandName;
   command_arg.arg_repetition = eArgRepeatStar;
 
-  // There is only one variant this argument could be; put it into the argument
-  // entry.
+  // There is only one variant this argument could be; put it into the
+  // argument entry.
   arg.push_back(command_arg);
 
   // Push the data for the first argument into the m_arguments vector.
@@ -89,10 +89,10 @@
   CommandObject *cmd_obj;
   const size_t argc = command.GetArgumentCount();
 
-  // 'help' doesn't take any arguments, other than command names.  If argc is 0,
-  // we show the user
-  // all commands (aliases and user commands if asked for).  Otherwise every
-  // argument must be the name of a command or a sub-command.
+  // 'help' doesn't take any arguments, other than command names.  If argc
+  // is 0, we show the user all commands (aliases and user commands if
+  // asked for).  Otherwise every argument must be the name of a command
+  // or a sub-command.
   if (argc == 0) {
     uint32_t cmd_types = CommandInterpreter::eCommandTypesBuiltin;
     if (m_options.m_show_aliases)
@@ -105,8 +105,8 @@
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     m_interpreter.GetHelp(result, cmd_types); // General help
   } else {
-    // Get command object for the first command argument. Only search built-in
-    // command dictionary.
+    // Get command object for the first command argument. Only search
+    // built-in command dictionary.
     StringList matches;
     auto command_name = command[0].ref;
     cmd_obj = m_interpreter.GetCommandObject(command_name, &matches);
@@ -115,8 +115,8 @@
       StringList matches;
       bool all_okay = true;
       CommandObject *sub_cmd_obj = cmd_obj;
-      // Loop down through sub_command dictionaries until we find the command
-      // object that corresponds to the help command entered.
+      // Loop down through sub_command dictionaries until we find the
+      // command object that corresponds to the help command entered.
       std::string sub_command;
       for (auto &entry : command.entries().drop_front()) {
         sub_command = entry.ref;
@@ -188,8 +188,8 @@
         output_strm.Printf("\t%s\n", matches.GetStringAtIndex(i));
       }
     } else {
-      // Maybe the user is asking for help about a command argument rather than
-      // a command.
+      // Maybe the user is asking for help about a command argument rather
+      // than a command.
       const CommandArgumentType arg_type =
           CommandObject::LookupArgumentName(command_name);
       if (arg_type != eArgTypeLastArg) {
@@ -224,9 +224,9 @@
   } else {
     CommandObject *cmd_obj = m_interpreter.GetCommandObject(input[0].ref);
 
-    // The command that they are getting help on might be ambiguous, in which
-    // case we should complete that,
-    // otherwise complete with the command the user is getting help on...
+    // The command that they are getting help on might be ambiguous, in
+    // which case we should complete that, otherwise complete with the
+    // command the user is getting help on...
 
     if (cmd_obj) {
       input.Shift();
Index: source/Commands/CommandObjectLog.cpp
===================================================================
--- source/Commands/CommandObjectLog.cpp
+++ source/Commands/CommandObjectLog.cpp
@@ -163,7 +163,8 @@
       return false;
     }
 
-    // Store into a std::string since we're about to shift the channel off.
+    // Store into a std::string since we're about to shift the channel
+    // off.
     const std::string channel = args[0].ref;
     args.Shift(); // Shift off the channel
     char log_file[PATH_MAX];
Index: source/Commands/CommandObjectMemory.cpp
===================================================================
--- source/Commands/CommandObjectMemory.cpp
+++ source/Commands/CommandObjectMemory.cpp
@@ -362,8 +362,8 @@
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    // No need to check "target" for validity as eCommandRequiresTarget ensures
-    // it is valid
+    // No need to check "target" for validity as eCommandRequiresTarget
+    // ensures it is valid
     Target *target = m_exe_ctx.GetTargetPtr();
 
     const size_t argc = command.GetArgumentCount();
@@ -574,8 +574,8 @@
 
     // TODO For non-8-bit byte addressable architectures this needs to be
     // revisited to fully support all lldb's range of formatting options.
-    // Furthermore code memory reads (for those architectures) will not
-    // be correctly formatted even w/o formatting options.
+    // Furthermore code memory reads (for those architectures) will not be
+    // correctly formatted even w/o formatting options.
     size_t item_byte_size =
         target->GetArchitecture().GetDataByteSize() > 1
             ? target->GetArchitecture().GetDataByteSize()
@@ -646,8 +646,8 @@
     DataBufferSP data_sp;
     size_t bytes_read = 0;
     if (clang_ast_type.GetOpaqueQualType()) {
-      // Make sure we don't display our type as ASCII bytes like the default
-      // memory read
+      // Make sure we don't display our type as ASCII bytes like the
+      // default memory read
       if (!m_format_options.GetFormatValue().OptionWasSet())
         m_format_options.GetFormatValue().SetCurrentValue(eFormatDefault);
 
@@ -690,8 +690,8 @@
             ") were able to be read from 0x%" PRIx64 ".\n",
             (uint64_t)bytes_read, (uint64_t)total_byte_size, addr);
     } else {
-      // we treat c-strings as a special case because they do not have a fixed
-      // size
+      // we treat c-strings as a special case because they do not have a
+      // fixed size
       if (m_format_options.GetByteSizeValue().OptionWasSet() &&
           !m_format_options.HasGDBFormat())
         item_byte_size = m_format_options.GetByteSizeValue().GetCurrentValue();
@@ -844,16 +844,15 @@
       if (!m_format_options.GetCountValue().OptionWasSet() || item_count == 1) {
         // this turns requests such as
         // memory read -fc -s10 -c1 *charPtrPtr
-        // which make no sense (what is a char of size 10?)
-        // into a request for fetching 10 chars of size 1 from the same memory
-        // location
+        // which make no sense (what is a char of size 10?) into a request
+        // for fetching 10 chars of size 1 from the same memory location
         format = eFormatCharArray;
         item_count = item_byte_size;
         item_byte_size = 1;
       } else {
-        // here we passed a count, and it was not 1
-        // so we have a byte_size and a count
-        // we could well multiply those, but instead let's just fail
+        // here we passed a count, and it was not 1 so we have a byte_size
+        // and a count we could well multiply those, but instead let's
+        // just fail
         result.AppendErrorWithFormat(
             "reading memory as characters of size %" PRIu64 " is not supported",
             (uint64_t)item_byte_size);
@@ -1446,8 +1445,8 @@
       case eFormatPointer:
       {
         // Decode hex bytes
-        // Be careful, getAsInteger with a radix of 16 rejects "0xab" so we
-        // have to special case that:
+        // Be careful, getAsInteger with a radix of 16 rejects "0xab" so
+        // we have to special case that:
         bool success = false;
         if (entry.ref.startswith("0x"))
           success = !entry.ref.getAsInteger(0, uval64);
@@ -1761,8 +1760,8 @@
 
   const char *GetRepeatCommand(Args &current_command_args,
                                uint32_t index) override {
-    // If we repeat this command, repeat it without any arguments so we can
-    // show the next memory range
+    // If we repeat this command, repeat it without any arguments so we
+    // can show the next memory range
     return m_cmd_name.c_str();
   }
 
Index: source/Commands/CommandObjectMultiword.cpp
===================================================================
--- source/Commands/CommandObjectMultiword.cpp
+++ source/Commands/CommandObjectMultiword.cpp
@@ -54,9 +54,8 @@
           AddNamesMatchingPartialString(m_subcommand_dict, sub_cmd, *matches);
 
       if (num_matches == 1) {
-        // Cleaner, but slightly less efficient would be to call back into this
-        // function, since I now
-        // know I have an exact match...
+        // Cleaner, but slightly less efficient would be to call back into
+        // this function, since I now know I have an exact match...
 
         sub_cmd = matches->GetStringAtIndex(0);
         pos = m_subcommand_dict.find(sub_cmd);
@@ -120,9 +119,9 @@
   StringList matches;
   CommandObject *sub_cmd_obj = GetSubcommandObject(sub_command, &matches);
   if (sub_cmd_obj != nullptr) {
-    // Now call CommandObject::Execute to process options in `rest_of_line`.
-    // From there the command-specific version of Execute will be called,
-    // with the processed arguments.
+    // Now call CommandObject::Execute to process options in
+    // `rest_of_line`. From there the command-specific version of Execute
+    // will be called, with the processed arguments.
 
     args.Shift();
     sub_cmd_obj->Execute(args_string, result);
@@ -193,8 +192,8 @@
                                              int max_return_elements,
                                              bool &word_complete,
                                              StringList &matches) {
-  // Any of the command matches will provide a complete word, otherwise the
-  // individual completers will override this.
+  // Any of the command matches will provide a complete word, otherwise
+  // the individual completers will override this.
   word_complete = true;
 
   auto arg0 = input[0].ref;
@@ -225,7 +224,8 @@
     if (sub_command_object == nullptr) {
       return matches.GetSize();
     } else {
-      // Remove the one match that we got from calling GetSubcommandObject.
+      // Remove the one match that we got from calling
+      // GetSubcommandObject.
       matches.DeleteStringAtIndex(0);
       input.Shift();
       cursor_index--;
Index: source/Commands/CommandObjectPlatform.cpp
===================================================================
--- source/Commands/CommandObjectPlatform.cpp
+++ source/Commands/CommandObjectPlatform.cpp
@@ -385,8 +385,8 @@
         Status error;
 
         if (platform_sp->IsConnected()) {
-          // Cache the instance name if there is one since we are
-          // about to disconnect and the name might go with it.
+          // Cache the instance name if there is one since we are about to
+          // disconnect and the name might go with it.
           const char *hostname_cstr = platform_sp->GetHostname();
           std::string hostname;
           if (hostname_cstr)
@@ -867,8 +867,8 @@
     // argument entry.
     arg2.push_back(file_arg_host);
 
-    // Push the data for the first and the second arguments into the m_arguments
-    // vector.
+    // Push the data for the first and the second arguments into the
+    // m_arguments vector.
     m_arguments.push_back(arg1);
     m_arguments.push_back(arg2);
   }
@@ -1059,8 +1059,8 @@
 
       if (argc > 0) {
         if (m_options.launch_info.GetExecutableFile()) {
-          // We already have an executable file, so we will use this
-          // and all arguments to this function are extra arguments
+          // We already have an executable file, so we will use this and
+          // all arguments to this function are extra arguments
           m_options.launch_info.GetArguments().AppendArguments(args);
         } else {
           // We don't have any file yet, so the first argument is our
@@ -1509,8 +1509,8 @@
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
-      // Keep default values of all options in one place: OptionParsingStarting
-      // ()
+      // Keep default values of all options in one place:
+      // OptionParsingStarting ()
       OptionParsingStarting(nullptr);
     }
 
@@ -1573,9 +1573,8 @@
       if (GetDefinitions()[opt_defs_index].short_option == 'n') {
         // Are we in the name?
 
-        // Look to see if there is a -P argument provided, and if so use that
-        // plugin, otherwise
-        // use the default plugin.
+        // Look to see if there is a -P argument provided, and if so use
+        // that plugin, otherwise use the default plugin.
 
         const char *partial_name = nullptr;
         partial_name = input.GetArgumentAtIndex(opt_arg_pos);
Index: source/Commands/CommandObjectProcess.cpp
===================================================================
--- source/Commands/CommandObjectProcess.cpp
+++ source/Commands/CommandObjectProcess.cpp
@@ -179,19 +179,19 @@
 
     llvm::StringRef target_settings_argv0 = target->GetArg0();
 
-    // Determine whether we will disable ASLR or leave it in the default state
-    // (i.e. enabled if the platform supports it).
-    // First check if the process launch options explicitly turn on/off
-    // disabling ASLR.  If so, use that setting;
-    // otherwise, use the 'settings target.disable-aslr' setting.
+    // Determine whether we will disable ASLR or leave it in the default
+    // state (i.e. enabled if the platform supports it). First check if
+    // the process launch options explicitly turn on/off disabling ASLR.
+    // If so, use that setting; otherwise, use the 'settings target
+    // .disable-aslr' setting.
     bool disable_aslr = false;
     if (m_options.disable_aslr != eLazyBoolCalculate) {
-      // The user specified an explicit setting on the process launch line.  Use
-      // it.
+      // The user specified an explicit setting on the process launch
+      // line.  Use it.
       disable_aslr = (m_options.disable_aslr == eLazyBoolYes);
     } else {
-      // The user did not explicitly specify whether to disable ASLR.  Fall back
-      // to the target.disable-aslr setting.
+      // The user did not explicitly specify whether to disable ASLR.
+      // Fall back to the target.disable-aslr setting.
       disable_aslr = target->GetDisableASLR();
     }
 
@@ -233,10 +233,9 @@
     if (error.Success()) {
       ProcessSP process_sp(target->GetProcessSP());
       if (process_sp) {
-        // There is a race condition where this thread will return up the call
-        // stack to the main command
-        // handler and show an (lldb) prompt before HandlePrivateEvent (from
-        // PrivateStateThread) has
+        // There is a race condition where this thread will return up the
+        // call stack to the main command handler and show an (lldb)
+        // prompt before HandlePrivateEvent (from PrivateStateThread) has
         // a chance to call PushProcessIOHandler().
         process_sp->SyncIOHandler(0, 2000);
 
@@ -328,8 +327,8 @@
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
-      // Keep default values of all options in one place: OptionParsingStarting
-      // ()
+      // Keep default values of all options in one place:
+      // OptionParsingStarting ()
       OptionParsingStarting(nullptr);
     }
 
@@ -400,9 +399,8 @@
       if (GetDefinitions()[opt_defs_index].short_option == 'n') {
         // Are we in the name?
 
-        // Look to see if there is a -P argument provided, and if so use that
-        // plugin, otherwise
-        // use the default plugin.
+        // Look to see if there is a -P argument provided, and if so use
+        // that plugin, otherwise use the default plugin.
 
         const char *partial_name = nullptr;
         partial_name = input.GetArgumentAtIndex(opt_arg_pos);
@@ -452,11 +450,10 @@
         m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
 
     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
-    // N.B. The attach should be synchronous.  It doesn't help much to get the
-    // prompt back between initiating the attach
-    // and the target actually stopping.  So even if the interpreter is set to
-    // be asynchronous, we wait for the stop
-    // ourselves here.
+    // N.B. The attach should be synchronous.  It doesn't help much to get
+    // the prompt back between initiating the attach and the target
+    // actually stopping.  So even if the interpreter is set to be
+    // asynchronous, we wait for the stop ourselves here.
 
     StateType state = eStateInvalid;
     Process *process = m_exe_ctx.GetProcessPtr();
@@ -482,9 +479,8 @@
     }
 
     // Record the old executable module, we want to issue a warning if the
-    // process of attaching changed the
-    // current executable (like somebody said "file foo" then attached to a PID
-    // whose executable was bar.)
+    // process of attaching changed the current executable (like somebody
+    // said "file foo" then attached to a PID whose executable was bar.)
 
     ModuleSP old_exec_module_sp = target->GetExecutableModule();
     ArchSpec old_arch_spec = target->GetArchitecture();
@@ -519,8 +515,8 @@
     if (!result.Succeeded())
       return false;
 
-    // Okay, we're done.  Last step is to warn if the executable module has
-    // changed:
+    // Okay, we're done.  Last step is to warn if the executable module
+    // has changed:
     char new_path[PATH_MAX];
     ModuleSP new_exec_module_sp(target->GetExecutableModule());
     if (!old_exec_module_sp) {
@@ -553,8 +549,8 @@
           target->GetArchitecture().GetTriple().getTriple().c_str());
     }
 
-    // This supports the use-case scenario of immediately continuing the process
-    // once attached.
+    // This supports the use-case scenario of immediately continuing the
+    // process once attached.
     if (m_options.attach_info.GetContinueOnceAttached())
       m_interpreter.HandleCommand("process continue", eLazyBoolNo, result);
 
@@ -593,8 +589,8 @@
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
-      // Keep default values of all options in one place: OptionParsingStarting
-      // ()
+      // Keep default values of all options in one place:
+      // OptionParsingStarting ()
       OptionParsingStarting(nullptr);
     }
 
@@ -691,18 +687,17 @@
         error = process->Resume();
 
       if (error.Success()) {
-        // There is a race condition where this thread will return up the call
-        // stack to the main command
-        // handler and show an (lldb) prompt before HandlePrivateEvent (from
-        // PrivateStateThread) has
+        // There is a race condition where this thread will return up the
+        // call stack to the main command handler and show an (lldb)
+        // prompt before HandlePrivateEvent (from PrivateStateThread) has
         // a chance to call PushProcessIOHandler().
         process->SyncIOHandler(iohandler_id, 2000);
 
         result.AppendMessageWithFormat("Process %" PRIu64 " resuming\n",
                                        process->GetID());
         if (synchronous_execution) {
-          // If any state changed events had anything to say, add that to the
-          // result
+          // If any state changed events had anything to say, add that to
+          // the result
           result.AppendMessage(stream.GetString());
 
           result.SetDidChangeProcessState(true);
@@ -844,8 +839,8 @@
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
-      // Keep default values of all options in one place: OptionParsingStarting
-      // ()
+      // Keep default values of all options in one place:
+      // OptionParsingStarting ()
       OptionParsingStarting(nullptr);
     }
 
@@ -973,8 +968,8 @@
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
-      // Keep default values of all options in one place: OptionParsingStarting
-      // ()
+      // Keep default values of all options in one place:
+      // OptionParsingStarting ()
       OptionParsingStarting(nullptr);
     }
 
@@ -1560,8 +1555,8 @@
         int32_t signo = signals_sp->GetSignalNumberFromName(arg.c_str());
         if (signo != LLDB_INVALID_SIGNAL_NUMBER) {
           // Casting the actions as bools here should be okay, because
-          // VerifyCommandOptionValue guarantees
-          // the value is either 0 or 1.
+          // VerifyCommandOptionValue guarantees the value is either 0 or
+          // 1.
           if (stop_action != -1)
             signals_sp->SetShouldStop(signo, stop_action);
           if (pass_action != -1) {
@@ -1577,8 +1572,8 @@
         }
       }
     } else {
-      // No signal specified, if any command options were specified, update ALL
-      // signals.
+      // No signal specified, if any command options were specified,
+      // update ALL signals.
       if ((notify_action != -1) || (stop_action != -1) || (pass_action != -1)) {
         if (m_interpreter.Confirm(
                 "Do you really want to update all the signals?", false)) {
Index: source/Commands/CommandObjectQuit.cpp
===================================================================
--- source/Commands/CommandObjectQuit.cpp
+++ source/Commands/CommandObjectQuit.cpp
@@ -30,10 +30,9 @@
 
 CommandObjectQuit::~CommandObjectQuit() {}
 
-// returns true if there is at least one alive process
-// is_a_detach will be true if all alive processes will be detached when you
-// quit
-// and false if at least one process will be killed instead
+// returns true if there is at least one alive process is_a_detach will be
+// true if all alive processes will be detached when you quit and false if
+// at least one process will be killed instead
 bool CommandObjectQuit::ShouldAskForConfirmation(bool &is_a_detach) {
   if (m_interpreter.GetPromptOnQuit() == false)
     return false;
@@ -56,7 +55,8 @@
           process_sp->WarnBeforeDetach()) {
         should_prompt = true;
         if (process_sp->GetShouldDetach() == false) {
-          // if we need to kill at least one process, just say so and return
+          // if we need to kill at least one process, just say so and
+          // return
           is_a_detach = false;
           return should_prompt;
         }
Index: source/Commands/CommandObjectRegister.cpp
===================================================================
--- source/Commands/CommandObjectRegister.cpp
+++ source/Commands/CommandObjectRegister.cpp
@@ -192,8 +192,8 @@
           num_register_sets = reg_ctx->GetRegisterSetCount();
 
         for (set_idx = 0; set_idx < num_register_sets; ++set_idx) {
-          // When dump_all_sets option is set, dump primitive as well as derived
-          // registers.
+          // When dump_all_sets option is set, dump primitive as well as
+          // derived registers.
           DumpRegisterSet(m_exe_ctx, strm, reg_ctx, set_idx,
                           !m_command_options.dump_all_sets.GetCurrentValue());
         }
@@ -209,11 +209,11 @@
         result.SetStatus(eReturnStatusFailed);
       } else {
         for (auto &entry : command) {
-          // in most LLDB commands we accept $rbx as the name for register RBX -
-          // and here we would reject it and non-existant. we should be more
-          // consistent towards the user and allow them to say reg read $rbx -
-          // internally, however, we should be strict and not allow ourselves
-          // to call our registers $rbx in our own API
+          // in most LLDB commands we accept $rbx as the name for register
+          // RBX - and here we would reject it and non-existant. we should
+          // be more consistent towards the user and allow them to say reg
+          // read $rbx - internally, however, we should be strict and not
+          // allow ourselves to call our registers $rbx in our own API
           auto arg_str = entry.ref;
           arg_str.consume_front("$");
 
@@ -264,17 +264,19 @@
       } break;
 
       case 'a':
-        // When we don't use OptionValue::SetValueFromCString(const char *) to
-        // set an option value, it won't be marked as being set in the options
-        // so we make a call to let users know the value was set via option
+        // When we don't use OptionValue::SetValueFromCString(const char
+        // *) to set an option value, it won't be marked as being set in
+        // the options so we make a call to let users know the value was
+        // set via option
         dump_all_sets.SetCurrentValue(true);
         dump_all_sets.SetOptionWasSet();
         break;
 
       case 'A':
-        // When we don't use OptionValue::SetValueFromCString(const char *) to
-        // set an option value, it won't be marked as being set in the options
-        // so we make a call to let users know the value was set via option
+        // When we don't use OptionValue::SetValueFromCString(const char
+        // *) to set an option value, it won't be marked as being set in
+        // the options so we make a call to let users know the value was
+        // set via option
         alternate_name.SetCurrentValue(true);
         dump_all_sets.SetOptionWasSet();
         break;
@@ -350,11 +352,11 @@
       auto reg_name = command[0].ref;
       auto value_str = command[1].ref;
 
-      // in most LLDB commands we accept $rbx as the name for register RBX - and
-      // here we would reject it and non-existant. we should be more consistent
-      // towards the user and allow them to say reg write $rbx - internally,
-      // however, we should be strict and not allow ourselves to call our
-      // registers $rbx in our own API
+      // in most LLDB commands we accept $rbx as the name for register RBX
+      // - and here we would reject it and non-existant. we should be more
+      // consistent towards the user and allow them to say reg write $rbx
+      // - internally, however, we should be strict and not allow
+      // ourselves to call our registers $rbx in our own API
       reg_name.consume_front("$");
 
       const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(reg_name);
@@ -365,8 +367,8 @@
         Status error(reg_value.SetValueFromString(reg_info, value_str));
         if (error.Success()) {
           if (reg_ctx->WriteRegister(reg_info, reg_value)) {
-            // Toss all frames and anything else in the thread
-            // after a register has been written.
+            // Toss all frames and anything else in the thread after a
+            // register has been written.
             m_exe_ctx.GetThreadRef().Flush();
             result.SetStatus(eReturnStatusSuccessFinishNoResult);
             return true;
Index: source/Commands/CommandObjectSettings.cpp
===================================================================
--- source/Commands/CommandObjectSettings.cpp
+++ source/Commands/CommandObjectSettings.cpp
@@ -219,12 +219,10 @@
 
     if (error.Success()) {
       // FIXME this is the same issue as the one in commands script import
-      // we could be setting target.load-script-from-symbol-file which would
-      // cause
-      // Python scripts to be loaded, which could run LLDB commands
-      // (e.g. settings set target.process.python-os-plugin-path) and cause a
-      // crash
-      // if we did not clear the command's exe_ctx first
+      // we could be setting target.load-script-from-symbol-file which
+      // would cause Python scripts to be loaded, which could run LLDB
+      // commands (e.g. settings set target.process.python-os-plugin-path)
+      // and cause a crash if we did not clear the command's exe_ctx first
       ExecutionContext exe_ctx(m_exe_ctx);
       m_exe_ctx.Clear();
       error = m_interpreter.GetDebugger().SetPropertyValue(
@@ -372,8 +370,8 @@
     if (argc > 0) {
       const bool dump_qualified_name = true;
 
-      // TODO: Convert to StringRef based enumeration.  Requires converting
-      // GetPropertyAtPath first.
+      // TODO: Convert to StringRef based enumeration.  Requires
+      // converting GetPropertyAtPath first.
       for (size_t i = 0; i < argc; ++i) {
         const char *property_path = args.GetArgumentAtIndex(i);
 
Index: source/Commands/CommandObjectSource.cpp
===================================================================
--- source/Commands/CommandObjectSource.cpp
+++ source/Commands/CommandObjectSource.cpp
@@ -148,16 +148,13 @@
   Options *GetOptions() override { return &m_options; }
 
 protected:
-  // Dump the line entries in each symbol context.
-  // Return the number of entries found.
-  // If module_list is set, only dump lines contained in one of the modules.
-  // If file_spec is set, only dump lines in the file.
+  // Dump the line entries in each symbol context. Return the number of
+  // entries found. If module_list is set, only dump lines contained in
+  // one of the modules. If file_spec is set, only dump lines in the file.
   // If the start_line option was specified, don't print lines less than
-  // start_line.
-  // If the end_line option was specified, don't print lines greater than
-  // end_line.
-  // If the num_lines option was specified, dont print more than num_lines
-  // entries.
+  // start_line. If the end_line option was specified, don't print lines
+  // greater than end_line. If the num_lines option was specified, dont
+  // print more than num_lines entries.
   uint32_t DumpLinesInSymbolContexts(Stream &strm,
                                      const SymbolContextList &sc_list,
                                      const ModuleList &module_list,
@@ -222,13 +219,11 @@
   }
 
   // Dump the requested line entries for the file in the compilation unit.
-  // Return the number of entries found.
-  // If module_list is set, only dump lines contained in one of the modules.
-  // If the start_line option was specified, don't print lines less than
-  // start_line.
-  // If the end_line option was specified, don't print lines greater than
-  // end_line.
-  // If the num_lines option was specified, dont print more than num_lines
+  // Return the number of entries found. If module_list is set, only dump
+  // lines contained in one of the modules. If the start_line option was
+  // specified, don't print lines less than start_line. If the end_line
+  // option was specified, don't print lines greater than end_line. If the
+  // num_lines option was specified, dont print more than num_lines
   // entries.
   uint32_t DumpFileLinesInCompUnit(Stream &strm, Module *module,
                                    CompileUnit *cu, const FileSpec &file_spec) {
@@ -249,8 +244,8 @@
         const FileSpec &cu_file_spec =
             cu_file_list.GetFileSpecAtIndex(file_idx);
 
-        // Dump all matching lines at or above start_line for the file in the
-        // CU.
+        // Dump all matching lines at or above start_line for the file in
+        // the CU.
         const ConstString &file_spec_name = file_spec.GetFilename();
         const ConstString &module_file_name =
             module->GetFileSpec().GetFilename();
@@ -259,8 +254,8 @@
         while (true) {
           LineEntry line_entry;
 
-          // Find the lowest index of a line entry with a line equal to
-          // or higher than 'line'.
+          // Find the lowest index of a line entry with a line equal to or
+          // higher than 'line'.
           uint32_t start_idx = 0;
           start_idx = cu->FindLineEntry(start_idx, line, &cu_file_spec,
                                         /*exact=*/false, &line_entry);
@@ -271,7 +266,8 @@
           if (end_line > 0 && line_entry.line > end_line)
             break;
 
-          // Loop through to find any other entries for this line, dumping each.
+          // Loop through to find any other entries for this line, dumping
+          // each.
           line = line_entry.line;
           do {
             num_matches++;
@@ -305,22 +301,19 @@
     return num_matches;
   }
 
-  // Dump the requested line entries for the file in the module.
-  // Return the number of entries found.
-  // If module_list is set, only dump lines contained in one of the modules.
-  // If the start_line option was specified, don't print lines less than
-  // start_line.
-  // If the end_line option was specified, don't print lines greater than
-  // end_line.
-  // If the num_lines option was specified, dont print more than num_lines
+  // Dump the requested line entries for the file in the module. Return
+  // the number of entries found. If module_list is set, only dump lines
+  // contained in one of the modules. If the start_line option was
+  // specified, don't print lines less than start_line. If the end_line
+  // option was specified, don't print lines greater than end_line. If the
+  // num_lines option was specified, dont print more than num_lines
   // entries.
   uint32_t DumpFileLinesInModule(Stream &strm, Module *module,
                                  const FileSpec &file_spec) {
     uint32_t num_matches = 0;
     if (module) {
-      // Look through all the compilation units (CUs) in this module for ones
-      // that
-      // contain lines of code from this source file.
+      // Look through all the compilation units (CUs) in this module for
+      // ones that contain lines of code from this source file.
       for (size_t i = 0; i < module->GetNumCompileUnits(); i++) {
         // Look for a matching source file in this CU.
         CompUnitSP cu_sp(module->GetCompileUnitAtIndex(i));
@@ -333,11 +326,10 @@
     return num_matches;
   }
 
-  // Given an address and a list of modules, append the symbol contexts of all
-  // line entries
-  // containing the address found in the modules and return the count of
-  // matches.  If none
-  // is found, return an error in 'error_strm'.
+  // Given an address and a list of modules, append the symbol contexts of
+  // all line entries containing the address found in the modules and
+  // return the count of matches.  If none is found, return an error in
+  // 'error_strm'.
   size_t GetSymbolContextsForAddress(const ModuleList &module_list,
                                      lldb::addr_t addr,
                                      SymbolContextList &sc_list,
@@ -347,8 +339,9 @@
     assert(module_list.GetSize() > 0);
     Target *target = m_exe_ctx.GetTargetPtr();
     if (target->GetSectionLoadList().IsEmpty()) {
-      // The target isn't loaded yet, we need to lookup the file address in
-      // all modules.  Note: the module list option does not apply to addresses.
+      // The target isn't loaded yet, we need to lookup the file address
+      // in all modules.  Note: the module list option does not apply to
+      // addresses.
       const size_t num_modules = module_list.GetSize();
       for (size_t i = 0; i < num_modules; ++i) {
         ModuleSP module_sp(module_list.GetModuleAtIndex(i));
@@ -409,8 +402,8 @@
     return num_matches;
   }
 
-  // Dump the line entries found in functions matching the name specified in the
-  // option.
+  // Dump the line entries found in functions matching the name specified
+  // in the option.
   bool DumpLinesInFunctions(CommandReturnObject &result) {
     SymbolContextList sc_list_funcs;
     ConstString name(m_options.symbol_name.c_str());
@@ -774,9 +767,9 @@
 
   const char *GetRepeatCommand(Args &current_command_args,
                                uint32_t index) override {
-    // This is kind of gross, but the command hasn't been parsed yet so we can't
-    // look at the option values for this invocation...  I have to scan the
-    // arguments directly.
+    // This is kind of gross, but the command hasn't been parsed yet so we
+    // can't look at the option values for this invocation...  I have to
+    // scan the arguments directly.
     auto iter =
         llvm::find_if(current_command_args, [](const Args::ArgEntry &e) {
           return e.ref == "-r" || e.ref == "--reverse";
@@ -863,12 +856,11 @@
         end_line = start_line + m_options.num_lines;
       }
 
-      // This is a little hacky, but the first line table entry for a function
-      // points to the "{" that
-      // starts the function block.  It would be nice to actually get the
-      // function
-      // declaration in there too.  So back up a bit, but not further than what
-      // you're going to display.
+      // This is a little hacky, but the first line table entry for a
+      // function points to the "{" that starts the function block.  It
+      // would be nice to actually get the function declaration in there
+      // too.  So back up a bit, but not further than what you're going to
+      // display.
       uint32_t extra_lines;
       if (m_options.num_lines >= 10)
         extra_lines = 5;
@@ -880,9 +872,8 @@
       else
         line_no = start_line - extra_lines;
 
-      // For fun, if the function is shorter than the number of lines we're
-      // supposed to display,
-      // only display the function...
+      // For fun, if the function is shorter than the number of lines
+      // we're supposed to display, only display the function...
       if (end_line != 0) {
         if (m_options.num_lines > end_line - line_no)
           m_options.num_lines = end_line - line_no + extra_lines;
@@ -913,14 +904,14 @@
     return 0;
   }
 
-  // From Jim: The FindMatchingFunctions / FindMatchingFunctionSymbols functions
-  // "take a possibly empty vector of strings which are names of modules, and
-  // run the two search functions on the subset of the full module list that
-  // matches the strings in the input vector". If we wanted to put these
-  // somewhere,
-  // there should probably be a module-filter-list that can be passed to the
-  // various ModuleList::Find* calls, which would either be a vector of string
-  // names or a ModuleSpecList.
+  // From Jim: The FindMatchingFunctions / FindMatchingFunctionSymbols
+  // functions "take a possibly empty vector of strings which are names of
+  // modules, and run the two search functions on the subset of the full
+  // module list that matches the strings in the input vector". If we
+  // wanted to put these somewhere, there should probably be a module-
+  // filter-list that can be passed to the various ModuleList::Find*
+  // calls, which would either be a vector of string names or a
+  // ModuleSpecList.
   size_t FindMatchingFunctions(Target *target, const ConstString &name,
                                SymbolContextList &sc_list) {
     // Displaying the source for a symbol:
@@ -993,12 +984,12 @@
       SymbolContextList sc_list;
       ConstString name(m_options.symbol_name.c_str());
 
-      // Displaying the source for a symbol. Search for function named name.
+      // Displaying the source for a symbol. Search for function named
+      // name.
       size_t num_matches = FindMatchingFunctions(target, name, sc_list);
       if (!num_matches) {
-        // If we didn't find any functions with that name, try searching for
-        // symbols
-        // that line up exactly with function addresses.
+        // If we didn't find any functions with that name, try searching
+        // for symbols that line up exactly with function addresses.
         SymbolContextList sc_list_symbols;
         size_t num_symbol_matches =
             FindMatchingFunctionSymbols(target, name, sc_list_symbols);
@@ -1170,10 +1161,9 @@
       }
     } else if (m_options.file_name.empty()) {
       // Last valid source manager context, or the current frame if no
-      // valid last context in source manager.
-      // One little trick here, if you type the exact same list command twice in
-      // a row, it is
-      // more likely because you typed it once, then typed it again
+      // valid last context in source manager. One little trick here, if
+      // you type the exact same list command twice in a row, it is more
+      // likely because you typed it once, then typed it again
       if (m_options.start_line == 0) {
         if (target->GetSourceManager().DisplayMoreWithLineNumbers(
                 &result.GetOutputStream(), m_options.num_lines,
Index: source/Commands/CommandObjectTarget.cpp
===================================================================
--- source/Commands/CommandObjectTarget.cpp
+++ source/Commands/CommandObjectTarget.cpp
@@ -273,11 +273,9 @@
           target_sp));
 
       if (target_sp) {
-        // Only get the platform after we create the target because we might
-        // have
-        // switched platforms depending on what the arguments were to
-        // CreateTarget()
-        // we can't rely on the selected platform.
+        // Only get the platform after we create the target because we
+        // might have switched platforms depending on what the arguments
+        // were to CreateTarget() we can't rely on the selected platform.
 
         PlatformSP platform_sp = target_sp->GetPlatform();
 
@@ -297,9 +295,8 @@
             } else {
               // there is no local file and we need one
               // in order to make the remote ---> local transfer we need a
-              // platform
-              // TODO: if the user has passed in a --platform argument, use it
-              // to fetch the right platform
+              // platform TODO: if the user has passed in a --platform
+              // argument, use it to fetch the right platform
               if (!platform_sp) {
                 result.AppendError(
                     "unable to perform remote debugging without a platform");
@@ -368,8 +365,8 @@
                 &core_file));
 
             if (process_sp) {
-              // Seems weird that we Launch a core file, but that is
-              // what we do!
+              // Seems weird that we Launch a core file, but that is what
+              // we do!
               error = process_sp->LoadCore();
 
               if (error.Fail()) {
@@ -924,8 +921,8 @@
             }
           }
         } else {
-          // No shared libraries, we just want to find globals for the compile
-          // units files that were specified
+          // No shared libraries, we just want to find globals for the
+          // compile units files that were specified
           for (size_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
             target->GetImages().FindCompileUnits(
                 compile_units.GetFileSpecAtIndex(cu_idx), append, sc_list);
@@ -997,12 +994,11 @@
     new_prefix_arg.arg_type = eArgTypeNewPathPrefix;
     new_prefix_arg.arg_repetition = eArgRepeatPairPlus;
 
-    // There are two required arguments that must always occur together, i.e. an
-    // argument "pair".  Because they
-    // must always occur together, they are treated as two variants of one
-    // argument rather than two independent
-    // arguments.  Push them both into the first argument position for
-    // m_arguments...
+    // There are two required arguments that must always occur together,
+    // i.e. an argument "pair".  Because they must always occur together,
+    // they are treated as two variants of one argument rather than two
+    // independent arguments.  Push them both into the first argument
+    // position for m_arguments...
 
     arg.push_back(old_prefix_arg);
     arg.push_back(new_prefix_arg);
@@ -1111,12 +1107,11 @@
     new_prefix_arg.arg_type = eArgTypeNewPathPrefix;
     new_prefix_arg.arg_repetition = eArgRepeatPairPlus;
 
-    // There are two required arguments that must always occur together, i.e. an
-    // argument "pair".  Because they
-    // must always occur together, they are treated as two variants of one
-    // argument rather than two independent
-    // arguments.  Push them both into the same argument position for
-    // m_arguments...
+    // There are two required arguments that must always occur together,
+    // i.e. an argument "pair".  Because they must always occur together,
+    // they are treated as two variants of one argument rather than two
+    // independent arguments.  Push them both into the same argument
+    // position for m_arguments...
 
     arg2.push_back(old_prefix_arg);
     arg2.push_back(new_prefix_arg);
@@ -1635,8 +1630,8 @@
       strm.PutCString(":\n");
       for (TypeSP type_sp : type_list.Types()) {
         if (type_sp) {
-          // Resolve the clang type so that any forward references
-          // to types that haven't yet been parsed will get parsed.
+          // Resolve the clang type so that any forward references to
+          // types that haven't yet been parsed will get parsed.
           type_sp->GetFullCompilerType();
           type_sp->GetDescription(&strm, eDescriptionLevelFull, true);
           // Print all typedef chains
@@ -1686,8 +1681,8 @@
 
     TypeSP type_sp(type_list.GetTypeAtIndex(0));
     if (type_sp) {
-      // Resolve the clang type so that any forward references
-      // to types that haven't yet been parsed will get parsed.
+      // Resolve the clang type so that any forward references to types
+      // that haven't yet been parsed will get parsed.
       type_sp->GetFullCompilerType();
       type_sp->GetDescription(&strm, eDescriptionLevelFull, true);
       // Print all typedef chains
@@ -1766,8 +1761,7 @@
           target->GetImages().FindModules(module_spec, module_list);
 
       // Not found in our module list for our target, check the main
-      // shared module list in case it is a extra file used somewhere
-      // else
+      // shared module list in case it is a extra file used somewhere else
       if (num_matches == 0) {
         module_spec.GetArchitecture() = target->GetArchitecture();
         ModuleList::FindSharedModules(module_spec, module_list);
@@ -2607,8 +2601,7 @@
       ModuleSpec module_spec;
       bool search_using_module_spec = false;
 
-      // Allow "load" option to work without --file or --uuid
-      // option.
+      // Allow "load" option to work without --file or --uuid option.
       if (load) {
         if (!m_file_option.GetOptionValue().OptionWasSet() &&
             !m_uuid_option_group.GetOptionValue().OptionWasSet()) {
@@ -2930,9 +2923,8 @@
     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
     const bool use_global_module_list = m_options.m_use_global_module_list;
     // Define a local module list here to ensure it lives longer than any
-    // "locker"
-    // object which might lock its contents below (through the "module_list_ptr"
-    // variable).
+    // "locker" object which might lock its contents below (through the
+    // "module_list_ptr" variable).
     ModuleList module_list;
     if (target == nullptr && !use_global_module_list) {
       result.AppendError("invalid target, create a debug target using the "
@@ -2979,11 +2971,10 @@
 
       size_t num_modules = 0;
 
-      // This locker will be locked on the mutex in module_list_ptr if it is
-      // non-nullptr.
-      // Otherwise it will lock the AllocationModuleCollectionMutex when
-      // accessing
-      // the global module list directly.
+      // This locker will be locked on the mutex in module_list_ptr if it
+      // is non-nullptr. Otherwise it will lock the
+      // AllocationModuleCollectionMutex when accessing the global module
+      // list directly.
       std::unique_lock<std::recursive_mutex> guard(
           Module::GetAllocationModuleCollectionMutex(), std::defer_lock);
 
@@ -3139,8 +3130,8 @@
                 }
                 break;
               }
-              // The address was valid, but the image isn't loaded, output the
-              // address in an appropriate format
+              // The address was valid, but the image isn't loaded, output
+              // the address in an appropriate format
               header_addr.Dump(&strm, target, Address::DumpStyleFileAddress);
               break;
             }
@@ -3153,7 +3144,8 @@
         size_t ref_count = 0;
         ModuleSP module_sp(module->shared_from_this());
         if (module_sp) {
-          // Take one away to make sure we don't count our local "module_sp"
+          // Take one away to make sure we don't count our local
+          // "module_sp"
           ref_count = module_sp.use_count() - 1;
         }
         if (width)
@@ -3832,8 +3824,8 @@
         ModuleSP current_module;
 
         // Where it is possible to look in the current symbol context
-        // first, try that.  If this search was successful and --all
-        // was not passed, don't print anything else.
+        // first, try that.  If this search was successful and --all was
+        // not passed, don't print anything else.
         if (LookupHere(m_interpreter, result, syntax_error)) {
           result.GetOutputStream().EOL();
           num_successful_lookups++;
@@ -4045,10 +4037,9 @@
         if (!module_spec.GetFileSpec() && !module_spec.GetPlatformFileSpec())
           module_spec.GetFileSpec().GetFilename() = symbol_fspec.GetFilename();
       }
-      // We now have a module that represents a symbol file
-      // that can be used for a module that might exist in the
-      // current target, so we need to find that module in the
-      // target
+      // We now have a module that represents a symbol file that can be
+      // used for a module that might exist in the current target, so we
+      // need to find that module in the target
       ModuleList matching_module_list;
 
       size_t num_matches = 0;
@@ -4056,7 +4047,8 @@
       lldb_private::ModuleSpecList symfile_module_specs;
       if (ObjectFile::GetModuleSpecifications(module_spec.GetSymbolFileSpec(),
                                               0, 0, symfile_module_specs)) {
-        // Now extract the module spec that matches the target architecture
+        // Now extract the module spec that matches the target
+        // architecture
         ModuleSpec target_arch_module_spec;
         ModuleSpec symfile_module_spec;
         target_arch_module_spec.GetArchitecture() = target->GetArchitecture();
@@ -4073,9 +4065,8 @@
         }
 
         if (num_matches == 0) {
-          // No matches yet, iterate through the module specs to find a UUID
-          // value that
-          // we can match up to an image in our target
+          // No matches yet, iterate through the module specs to find a
+          // UUID value that we can match up to an image in our target
           const size_t num_symfile_module_specs =
               symfile_module_specs.GetSize();
           for (size_t i = 0; i < num_symfile_module_specs && num_matches == 0;
@@ -4095,8 +4086,8 @@
         }
       }
 
-      // Just try to match up the file by basename if we have no matches at this
-      // point
+      // Just try to match up the file by basename if we have no matches
+      // at this point
       if (num_matches == 0)
         num_matches =
             target->GetImages().FindModules(module_spec, matching_module_list);
@@ -4108,7 +4099,8 @@
         if (!filename_no_extension)
           break;
 
-        // Check if there was no extension to strip and the basename is the same
+        // Check if there was no extension to strip and the basename is
+        // the same
         if (filename_no_extension == module_spec.GetFileSpec().GetFilename())
           break;
 
@@ -4141,20 +4133,22 @@
             ObjectFile *object_file = symbol_file->GetObjectFile();
 
             if (object_file && object_file->GetFileSpec() == symbol_fspec) {
-              // Provide feedback that the symfile has been successfully added.
+              // Provide feedback that the symfile has been successfully
+              // added.
               const FileSpec &module_fs = module_sp->GetFileSpec();
               result.AppendMessageWithFormat(
                   "symbol file '%s' has been added to '%s'\n", symfile_path,
                   module_fs.GetPath().c_str());
 
-              // Let clients know something changed in the module
-              // if it is currently loaded
+              // Let clients know something changed in the module if it is
+              // currently loaded
               ModuleList module_list;
               module_list.Append(module_sp);
               target->SymbolsDidLoad(module_list);
 
-              // Make sure we load any scripting resources that may be embedded
-              // in the debug info files in case the platform supports that.
+              // Make sure we load any scripting resources that may be
+              // embedded in the debug info files in case the platform
+              // supports that.
               Status error;
               StreamString feedback_stream;
               module_sp->LoadScriptingResourceInTarget(target, error,
Index: source/Commands/CommandObjectThread.cpp
===================================================================
--- source/Commands/CommandObjectThread.cpp
+++ source/Commands/CommandObjectThread.cpp
@@ -74,9 +74,9 @@
     }
 
   protected:
-    // Mark the thread index as mutable, as we don't care about it from a const
-    // perspective, we only care about m_stack_frames so we keep our std::set
-    // sorted.
+    // Mark the thread index as mutable, as we don't care about it from a
+    // const perspective, we only care about m_stack_frames so we keep our
+    // std::set sorted.
     mutable std::vector<uint32_t> m_thread_index_ids;
     std::stack<lldb::addr_t> m_stack_frames;
   };
@@ -104,8 +104,8 @@
     }
 
     // Use tids instead of ThreadSPs to prevent deadlocking problems which
-    // result from JIT-ing
-    // code while iterating over the (locked) ThreadSP list.
+    // result from JIT-ing code while iterating over the (locked) ThreadSP
+    // list.
     std::vector<lldb::tid_t> tids;
 
     if (all_threads || m_unique_stacks) {
@@ -194,13 +194,12 @@
 protected:
   // Override this to do whatever you need to do for one thread.
   //
-  // If you return false, the iteration will stop, otherwise it will proceed.
-  // The result is set to m_success_return (defaults to
-  // eReturnStatusSuccessFinishResult) before the iteration,
-  // so you only need to set the return status in HandleOneThread if you want to
-  // indicate an error.
-  // If m_add_return is true, a blank line will be inserted between each of the
-  // listings (except the last one.)
+  // If you return false, the iteration will stop, otherwise it will
+  // proceed. The result is set to m_success_return (defaults to
+  // eReturnStatusSuccessFinishResult) before the iteration, so you only
+  // need to set the return status in HandleOneThread if you want to
+  // indicate an error. If m_add_return is true, a blank line will be
+  // inserted between each of the listings (except the last one.)
 
   virtual bool HandleOneThread(lldb::tid_t, CommandReturnObject &result) = 0;
 
@@ -261,8 +260,8 @@
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
-      // Keep default values of all options in one place: OptionParsingStarting
-      // ()
+      // Keep default values of all options in one place:
+      // OptionParsingStarting ()
       OptionParsingStarting(nullptr);
     }
 
@@ -433,8 +432,8 @@
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
-      // Keep default values of all options in one place: OptionParsingStarting
-      // ()
+      // Keep default values of all options in one place:
+      // OptionParsingStarting ()
       OptionParsingStarting(nullptr);
     }
 
@@ -647,8 +646,7 @@
     const lldb::RunMode stop_other_threads = m_options.m_run_mode;
 
     // This is a bit unfortunate, but not all the commands in this command
-    // object support
-    // only while stepping, so I use the bool for them.
+    // object support only while stepping, so I use the bool for them.
     bool bool_stop_other_threads;
     if (m_options.m_run_mode == eAllThreads)
       bool_stop_other_threads = false;
@@ -752,9 +750,9 @@
       return false;
     }
 
-    // If we got a new plan, then set it to be a master plan (User level Plans
-    // should be master plans
-    // so that they can be interruptible).  Then resume the process.
+    // If we got a new plan, then set it to be a master plan (User level
+    // Plans should be master plans so that they can be interruptible).
+    // Then resume the process.
 
     if (new_plan_sp) {
       new_plan_sp->SetIsMasterPlan(true);
@@ -784,16 +782,15 @@
         return false;
       }
 
-      // There is a race condition where this thread will return up the call
-      // stack to the main command handler
-      // and show an (lldb) prompt before HandlePrivateEvent (from
-      // PrivateStateThread) has
-      // a chance to call PushProcessIOHandler().
+      // There is a race condition where this thread will return up the
+      // call stack to the main command handler and show an (lldb) prompt
+      // before HandlePrivateEvent (from PrivateStateThread) has a chance
+      // to call PushProcessIOHandler().
       process->SyncIOHandler(iohandler_id, 2000);
 
       if (synchronous_execution) {
-        // If any state changed events had anything to say, add that to the
-        // result
+        // If any state changed events had anything to say, add that to
+        // the result
         if (stream.GetSize() > 0)
           result.AppendMessage(stream.GetString());
 
@@ -870,9 +867,9 @@
         (state == eStateSuspended)) {
       const size_t argc = command.GetArgumentCount();
       if (argc > 0) {
-        // These two lines appear at the beginning of both blocks in
-        // this if..else, but that is because we need to release the
-        // lock before calling process->Resume below.
+        // These two lines appear at the beginning of both blocks in this
+        // if..else, but that is because we need to release the lock
+        // before calling process->Resume below.
         std::lock_guard<std::recursive_mutex> guard(
             process->GetThreadList().GetMutex());
         const uint32_t num_threads = process->GetThreadList().GetSize();
@@ -931,9 +928,9 @@
                                          process->GetID());
         }
       } else {
-        // These two lines appear at the beginning of both blocks in
-        // this if..else, but that is because we need to release the
-        // lock before calling process->Resume below.
+        // These two lines appear at the beginning of both blocks in this
+        // if..else, but that is because we need to release the lock
+        // before calling process->Resume below.
         std::lock_guard<std::recursive_mutex> guard(
             process->GetThreadList().GetMutex());
         const uint32_t num_threads = process->GetThreadList().GetSize();
@@ -970,8 +967,8 @@
         result.AppendMessageWithFormat("Process %" PRIu64 " resuming\n",
                                        process->GetID());
         if (synchronous_execution) {
-          // If any state changed events had anything to say, add that to the
-          // result
+          // If any state changed events had anything to say, add that to
+          // the result
           if (stream.GetSize() > 0)
             result.AppendMessage(stream.GetString());
 
@@ -1019,8 +1016,8 @@
     CommandOptions()
         : Options(), m_thread_idx(LLDB_INVALID_THREAD_ID),
           m_frame_idx(LLDB_INVALID_FRAME_ID) {
-      // Keep default values of all options in one place: OptionParsingStarting
-      // ()
+      // Keep default values of all options in one place:
+      // OptionParsingStarting ()
       OptionParsingStarting(nullptr);
     }
 
@@ -1195,8 +1192,8 @@
       ThreadPlanSP new_plan_sp;
 
       if (frame->HasDebugInformation()) {
-        // Finally we got here...  Translate the given line number to a bunch of
-        // addresses:
+        // Finally we got here...  Translate the given line number to a
+        // bunch of addresses:
         SymbolContext sc(frame->GetSymbolContext(eSymbolContextCompUnit));
         LineTable *line_table = nullptr;
         if (sc.comp_unit)
@@ -1274,11 +1271,10 @@
         new_plan_sp = thread->QueueThreadPlanForStepUntil(
             abort_other_plans, &address_list.front(), address_list.size(),
             m_options.m_stop_others, m_options.m_frame_idx);
-        // User level plans should be master plans so they can be interrupted
-        // (e.g. by hitting a breakpoint)
-        // and other plans executed by the user (stepping around the breakpoint)
-        // and then a "continue"
-        // will resume the original plan.
+        // User level plans should be master plans so they can be
+        // interrupted (e.g. by hitting a breakpoint) and other plans
+        // executed by the user (stepping around the breakpoint) and then
+        // a "continue" will resume the original plan.
         new_plan_sp->SetIsMasterPlan(true);
         new_plan_sp->SetOkayToDiscard(false);
       } else {
@@ -1302,8 +1298,8 @@
         result.AppendMessageWithFormat("Process %" PRIu64 " resuming\n",
                                        process->GetID());
         if (synchronous_execution) {
-          // If any state changed events had anything to say, add that to the
-          // result
+          // If any state changed events had anything to say, add that to
+          // the result
           if (stream.GetSize() > 0)
             result.AppendMessage(stream.GetString());
 
@@ -1529,8 +1525,8 @@
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options(), m_from_expression(false) {
-      // Keep default values of all options in one place: OptionParsingStarting
-      // ()
+      // Keep default values of all options in one place:
+      // OptionParsingStarting ()
       OptionParsingStarting(nullptr);
     }
 
@@ -1608,9 +1604,8 @@
 
 protected:
   bool DoExecute(const char *command, CommandReturnObject &result) override {
-    // I am going to handle this by hand, because I don't want you to have to
-    // say:
-    // "thread return -- -5".
+    // I am going to handle this by hand, because I don't want you to have
+    // to say: "thread return -- -5".
     if (command[0] == '-' && command[1] == 'x') {
       if (command && command[2] != '\0')
         result.AppendWarning("Return values ignored when returning from user "
@@ -1859,8 +1854,8 @@
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
-      // Keep default values of all options in one place: OptionParsingStarting
-      // ()
+      // Keep default values of all options in one place:
+      // OptionParsingStarting ()
       OptionParsingStarting(nullptr);
     }
 
Index: source/Commands/CommandObjectType.cpp
===================================================================
--- source/Commands/CommandObjectType.cpp
+++ source/Commands/CommandObjectType.cpp
@@ -206,8 +206,8 @@
                                  "the script interpreter.\n");
                 error_sp->Flush();
               } else {
-                // now I have a valid function name, let's add this as script
-                // for every type in the list
+                // now I have a valid function name, let's add this as
+                // script for every type in the list
 
                 TypeSummaryImplSP script_format;
                 script_format.reset(new ScriptSummaryFormat(
@@ -450,8 +450,8 @@
                     "error: unable to obtain a proper name for the class.\n");
                 error_sp->Flush();
               } else {
-                // everything should be fine now, let's add the synth provider
-                // class
+                // everything should be fine now, let's add the synth
+                // provider class
 
                 SyntheticChildrenSP synth_provider;
                 synth_provider.reset(new ScriptedSyntheticChildren(
@@ -1421,8 +1421,8 @@
     return result.Succeeded();
   }
 
-  // if I am here, script_format must point to something good, so I can add that
-  // as a script summary to all interested parties
+  // if I am here, script_format must point to something good, so I can
+  // add that as a script summary to all interested parties
 
   Status error;
 
@@ -2756,10 +2756,9 @@
 
 class CommandObjectTypeLookup : public CommandObjectRaw {
 protected:
-  // this function is allowed to do a more aggressive job at guessing languages
-  // than the expression parser
-  // is comfortable with - so leave the original call alone and add one that is
-  // specific to type lookup
+  // this function is allowed to do a more aggressive job at guessing
+  // languages than the expression parser is comfortable with - so leave
+  // the original call alone and add one that is specific to type lookup
   lldb::LanguageType GuessLanguage(StackFrame *frame) {
     lldb::LanguageType lang_type = lldb::eLanguageTypeUnknown;
 
@@ -2913,8 +2912,8 @@
 
     // TargetSP
     // target_sp(GetCommandInterpreter().GetDebugger().GetSelectedTarget());
-    // const bool fill_all_in = true;
-    // ExecutionContext exe_ctx(target_sp.get(), fill_all_in);
+    // const bool fill_all_in = true; ExecutionContext
+    // exe_ctx(target_sp.get(), fill_all_in);
     ExecutionContextScope *best_scope = exe_ctx.GetBestExecutionContextScope();
 
     bool any_found = false;
@@ -2933,10 +2932,9 @@
       languages.push_back(Language::FindPlugin(m_command_options.m_language));
     }
 
-    // This is not the most efficient way to do this, but we support very few
-    // languages
-    // so the cost of the sort is going to be dwarfed by the actual lookup
-    // anyway
+    // This is not the most efficient way to do this, but we support very
+    // few languages so the cost of the sort is going to be dwarfed by the
+    // actual lookup anyway
     if (StackFrame *frame = m_exe_ctx.GetFramePtr()) {
       guessed_language = GuessLanguage(frame);
       if (guessed_language != eLanguageTypeUnknown) {
@@ -2974,7 +2972,8 @@
           }
         }
       }
-      // this is "type lookup SomeName" and we did find a match, so get out
+      // this is "type lookup SomeName" and we did find a match, so get
+      // out
       if (any_found && is_global_search)
         break;
       else if (is_first_language && is_global_search &&
Index: source/Commands/CommandObjectWatchpoint.cpp
===================================================================
--- source/Commands/CommandObjectWatchpoint.cpp
+++ source/Commands/CommandObjectWatchpoint.cpp
@@ -96,8 +96,8 @@
   llvm::StringRef second;
   size_t i;
   int32_t idx;
-  // Go through the arguments and make a canonical form of arg list containing
-  // only numbers with possible "-" in between.
+  // Go through the arguments and make a canonical form of arg list
+  // containing only numbers with possible "-" in between.
   for (auto &entry : args.entries()) {
     if ((idx = WithRSAIndex(entry.ref)) == -1) {
       StrRefArgs.push_back(entry.ref);
@@ -112,7 +112,8 @@
       StrRefArgs.push_back(second);
   }
   // Now process the canonical list and fill in the vector of uint32_t's.
-  // If there is any error, return false and the client should ignore wp_ids.
+  // If there is any error, return false and the client should ignore
+  // wp_ids.
   uint32_t beg, end, id;
   size_t size = StrRefArgs.size();
   bool in_range = false;
@@ -178,8 +179,8 @@
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
-    // Add the entry for the first argument for this command to the object's
-    // arguments vector.
+    // Add the entry for the first argument for this command to the
+    // object's arguments vector.
     m_arguments.push_back(arg);
   }
 
@@ -269,7 +270,8 @@
     Stream &output_stream = result.GetOutputStream();
 
     if (command.GetArgumentCount() == 0) {
-      // No watchpoint selected; show info about all currently set watchpoints.
+      // No watchpoint selected; show info about all currently set
+      // watchpoints.
       result.AppendMessage("Current watchpoints:");
       for (size_t i = 0; i < num_watchpoints; ++i) {
         Watchpoint *wp = watchpoints.GetByIndex(i).get();
@@ -317,8 +319,8 @@
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
-    // Add the entry for the first argument for this command to the object's
-    // arguments vector.
+    // Add the entry for the first argument for this command to the
+    // object's arguments vector.
     m_arguments.push_back(arg);
   }
 
@@ -389,8 +391,8 @@
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
-    // Add the entry for the first argument for this command to the object's
-    // arguments vector.
+    // Add the entry for the first argument for this command to the
+    // object's arguments vector.
     m_arguments.push_back(arg);
   }
 
@@ -463,8 +465,8 @@
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
-    // Add the entry for the first argument for this command to the object's
-    // arguments vector.
+    // Add the entry for the first argument for this command to the
+    // object's arguments vector.
     m_arguments.push_back(arg);
   }
 
@@ -546,8 +548,8 @@
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
-    // Add the entry for the first argument for this command to the object's
-    // arguments vector.
+    // Add the entry for the first argument for this command to the
+    // object's arguments vector.
     m_arguments.push_back(arg);
   }
 
@@ -674,8 +676,8 @@
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
-    // Add the entry for the first argument for this command to the object's
-    // arguments vector.
+    // Add the entry for the first argument for this command to the
+    // object's arguments vector.
     m_arguments.push_back(arg);
   }
 
@@ -848,8 +850,8 @@
     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
     StackFrame *frame = m_exe_ctx.GetFramePtr();
 
-    // If no argument is present, issue an error message.  There's no way to set
-    // a watchpoint.
+    // If no argument is present, issue an error message.  There's no way
+    // to set a watchpoint.
     if (command.GetArgumentCount() <= 0) {
       result.GetErrorStream().Printf("error: required argument missing; "
                                      "specify your program variable to watch "
@@ -863,8 +865,8 @@
       m_option_watchpoint.watch_type = OptionGroupWatchpoint::eWatchWrite;
     }
 
-    // We passed the sanity check for the command.
-    // Proceed to set the watchpoint now.
+    // We passed the sanity check for the command. Proceed to set the
+    // watchpoint now.
     lldb::addr_t addr = 0;
     size_t size = 0;
 
@@ -1072,8 +1074,8 @@
     if (expr == nullptr)
       expr = raw_command;
 
-    // If no argument is present, issue an error message.  There's no way to set
-    // a watchpoint.
+    // If no argument is present, issue an error message.  There's no way
+    // to set a watchpoint.
     if (command.GetArgumentCount() == 0) {
       result.GetErrorStream().Printf("error: required argument missing; "
                                      "specify an expression to evaulate into "
@@ -1087,8 +1089,8 @@
       m_option_watchpoint.watch_type = OptionGroupWatchpoint::eWatchWrite;
     }
 
-    // We passed the sanity check for the command.
-    // Proceed to set the watchpoint now.
+    // We passed the sanity check for the command. Proceed to set the
+    // watchpoint now.
     lldb::addr_t addr = 0;
     size_t size = 0;
 
@@ -1130,8 +1132,8 @@
     // Now it's time to create the watchpoint.
     uint32_t watch_type = m_option_watchpoint.watch_type;
 
-    // Fetch the type from the value object, the type of the watched object is
-    // the pointee type
+    // Fetch the type from the value object, the type of the watched
+    // object is the pointee type
     /// of the expression, so convert to that if we  found a valid type.
     CompilerType compiler_type(valobj_sp->GetCompilerType());
 
Index: source/Commands/CommandObjectWatchpointCommand.cpp
===================================================================
--- source/Commands/CommandObjectWatchpointCommand.cpp
+++ source/Commands/CommandObjectWatchpointCommand.cpp
@@ -33,10 +33,10 @@
 // CommandObjectWatchpointCommandAdd
 //-------------------------------------------------------------------------
 
-// FIXME: "script-type" needs to have its contents determined dynamically, so
-// somebody can add a new scripting
-// language to lldb and have it pickable here without having to change this
-// enumeration by hand and rebuild lldb proper.
+// FIXME: "script-type" needs to have its contents determined dynamically,
+// so somebody can add a new scripting language to lldb and have it
+// pickable here without having to change this enumeration by hand and
+// rebuild lldb proper.
 
 static OptionEnumValueElement g_script_option_enumeration[4] = {
     {eScriptLanguageNone, "command",
@@ -222,8 +222,8 @@
                               std::string &line) override {
     io_handler.SetIsDone(true);
 
-    // The WatchpointOptions object is owned by the watchpoint or watchpoint
-    // location
+    // The WatchpointOptions object is owned by the watchpoint or
+    // watchpoint location
     WatchpointOptions *wp_options =
         (WatchpointOptions *)io_handler.GetUserData();
     if (wp_options) {
@@ -254,11 +254,10 @@
     std::unique_ptr<WatchpointOptions::CommandData> data_ap(
         new WatchpointOptions::CommandData());
 
-    // It's necessary to set both user_source and script_source to the oneliner.
-    // The former is used to generate callback description (as in watchpoint
-    // command list)
-    // while the latter is used for Python to interpret during the actual
-    // callback.
+    // It's necessary to set both user_source and script_source to the
+    // oneliner. The former is used to generate callback description (as
+    // in watchpoint command list) while the latter is used for Python to
+    // interpret during the actual callback.
     data_ap->user_source.AppendString(oneliner);
     data_ap->script_source.assign(oneliner);
     data_ap->stop_on_error = m_options.m_stop_on_error;
@@ -286,9 +285,9 @@
       if (target) {
         CommandReturnObject result;
         Debugger &debugger = target->GetDebugger();
-        // Rig up the results secondary output stream to the debugger's, so the
-        // output will come out synchronously
-        // if the debugger is set up that way.
+        // Rig up the results secondary output stream to the debugger's,
+        // so the output will come out synchronously if the debugger is
+        // set up that way.
 
         StreamSP output_stream(debugger.GetAsyncOutputStream());
         StreamSP error_stream(debugger.GetAsyncErrorStream());
@@ -441,20 +440,19 @@
         if (wp_options == nullptr)
           continue;
 
-        // If we are using script language, get the script interpreter
-        // in order to set or collect command callback.  Otherwise, call
-        // the methods associated with this object.
+        // If we are using script language, get the script interpreter in
+        // order to set or collect command callback.  Otherwise, call the
+        // methods associated with this object.
         if (m_options.m_use_script_language) {
           // Special handling for one-liner specified inline.
           if (m_options.m_use_one_liner) {
             m_interpreter.GetScriptInterpreter()->SetWatchpointCommandCallback(
                 wp_options, m_options.m_one_liner.c_str());
           }
-          // Special handling for using a Python function by name
-          // instead of extending the watchpoint callback data structures, we
-          // just automatize
-          // what the user would do manually: make their watchpoint command be a
-          // function call
+          // Special handling for using a Python function by name instead
+          // of extending the watchpoint callback data structures, we just
+          // automatize what the user would do manually: make their
+          // watchpoint command be a function call
           else if (!m_options.m_function_name.empty()) {
             std::string oneliner(m_options.m_function_name);
             oneliner += "(frame, wp, internal_dict)";
@@ -635,7 +633,8 @@
         if (wp) {
           const WatchpointOptions *wp_options = wp->GetOptions();
           if (wp_options) {
-            // Get the callback baton associated with the current watchpoint.
+            // Get the callback baton associated with the current
+            // watchpoint.
             const Baton *baton = wp_options->GetBaton();
             if (baton) {
               result.GetOutputStream().Printf("Watchpoint %u:\n", cur_wp_id);
Index: source/Core/Address.cpp
===================================================================
--- source/Core/Address.cpp
+++ source/Core/Address.cpp
@@ -141,8 +141,8 @@
                                                           deref_so_addr))
         return true;
     } else {
-      // If we were not running, yet able to read an integer, we must
-      // have a module
+      // If we were not running, yet able to read an integer, we must have
+      // a module
       ModuleSP module_sp(address.GetModule());
 
       assert(module_sp);
@@ -150,9 +150,9 @@
         return true;
     }
 
-    // We couldn't make "deref_addr" into a section offset value, but we were
-    // able to read the address, so we return a section offset address with
-    // no section and "deref_addr" as the offset (address).
+    // We couldn't make "deref_addr" into a section offset value, but we
+    // were able to read the address, so we return a section offset
+    // address with no section and "deref_addr" as the offset (address).
     deref_so_addr.SetRawAddress(deref_addr);
     return true;
   }
@@ -278,15 +278,16 @@
       // Section isn't resolved, we can't return a valid file address
       return LLDB_INVALID_ADDRESS;
     }
-    // We have a valid file range, so we can return the file based
-    // address by adding the file base address to our offset
+    // We have a valid file range, so we can return the file based address
+    // by adding the file base address to our offset
     return sect_file_addr + m_offset;
   } else if (SectionWasDeletedPrivate()) {
-    // Used to have a valid section but it got deleted so the
-    // offset doesn't mean anything without the section
+    // Used to have a valid section but it got deleted so the offset
+    // doesn't mean anything without the section
     return LLDB_INVALID_ADDRESS;
   }
-  // No section, we just return the offset since it is the value in this case
+  // No section, we just return the offset since it is the value in this
+  // case
   return m_offset;
 }
 
@@ -303,15 +304,15 @@
       }
     }
   } else if (SectionWasDeletedPrivate()) {
-    // Used to have a valid section but it got deleted so the
-    // offset doesn't mean anything without the section
+    // Used to have a valid section but it got deleted so the offset
+    // doesn't mean anything without the section
     return LLDB_INVALID_ADDRESS;
   } else {
     // We don't have a section so the offset is the load address
     return m_offset;
   }
-  // The section isn't resolved or an invalid target was passed in
-  // so we can't return a valid load address.
+  // The section isn't resolved or an invalid target was passed in so we
+  // can't return a valid load address.
   return LLDB_INVALID_ADDRESS;
 }
 
@@ -374,9 +375,8 @@
 
 bool Address::Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style,
                    DumpStyle fallback_style, uint32_t addr_size) const {
-  // If the section was nullptr, only load address is going to work unless we
-  // are
-  // trying to deref a pointer
+  // If the section was nullptr, only load address is going to work unless
+  // we are trying to deref a pointer
   SectionSP section_sp(GetSection());
   if (!section_sp && style != DumpStyleResolvedPointerDescription)
     style = DumpStyleLoadAddress;
@@ -642,24 +642,26 @@
                 (style != DumpStyleResolvedDescriptionNoFunctionArguments);
             const bool show_function_name = (style != DumpStyleNoFunctionName);
             if (sc.function == nullptr && sc.symbol != nullptr) {
-              // If we have just a symbol make sure it is in the right section
+              // If we have just a symbol make sure it is in the right
+              // section
               if (sc.symbol->ValueIsAddress()) {
                 if (sc.symbol->GetAddressRef().GetSection() != GetSection()) {
-                  // don't show the module if the symbol is a trampoline symbol
+                  // don't show the module if the symbol is a trampoline
+                  // symbol
                   show_stop_context = false;
                 }
               }
             }
             if (show_stop_context) {
-              // We have a function or a symbol from the same
-              // sections as this address.
+              // We have a function or a symbol from the same sections as
+              // this address.
               sc.DumpStopContext(s, exe_scope, *this, show_fullpaths,
                                  show_module, show_inlined_frames,
                                  show_function_arguments, show_function_name);
             } else {
-              // We found a symbol but it was in a different
-              // section so it isn't the symbol we should be
-              // showing, just show the section name + offset
+              // We found a symbol but it was in a different section so it
+              // isn't the symbol we should be showing, just show the
+              // section name + offset
               Dump(s, exe_scope, DumpStyleSectionNameOffset);
             }
           }
@@ -770,15 +772,12 @@
 bool Address::SectionWasDeletedPrivate() const {
   lldb::SectionWP empty_section_wp;
 
-  // If either call to "std::weak_ptr::owner_before(...) value returns true,
-  // this
-  // indicates that m_section_wp once contained (possibly still does) a
-  // reference
-  // to a valid shared pointer. This helps us know if we had a valid reference
-  // to
-  // a section which is now invalid because the module it was in was
-  // unloaded/deleted,
-  // or if the address doesn't have a valid reference to a section.
+  // If either call to "std::weak_ptr::owner_before(...) value returns
+  // true, this indicates that m_section_wp once contained (possibly still
+  // does) a reference to a valid shared pointer. This helps us know if we
+  // had a valid reference to a section which is now invalid because the
+  // module it was in was unloaded/deleted, or if the address doesn't have
+  // a valid reference to a section.
   return empty_section_wp.owner_before(m_section_wp) ||
          m_section_wp.owner_before(empty_section_wp);
 }
@@ -786,8 +785,8 @@
 uint32_t Address::CalculateSymbolContext(SymbolContext *sc,
                                          uint32_t resolve_scope) const {
   sc->Clear(false);
-  // Absolute addresses don't have enough information to reconstruct even their
-  // target.
+  // Absolute addresses don't have enough information to reconstruct even
+  // their target.
 
   SectionSP section_sp(GetSection());
   if (section_sp) {
@@ -926,8 +925,8 @@
 }
 
 size_t Address::MemorySize() const {
-  // Noting special for the memory size of a single Address object,
-  // it is just the size of itself.
+  // Noting special for the memory size of a single Address object, it is
+  // just the size of itself.
   return sizeof(Address);
 }
 
@@ -938,8 +937,8 @@
 // compare the module pointers.
 //
 // To sum things up:
-// - works great for addresses within the same module
-// - it works for addresses across multiple modules, but don't expect the
+// - works great for addresses within the same module - it works for
+// addresses across multiple modules, but don't expect the
 //   address results to make much sense
 //
 // This basically lets Address objects be used in ordered collection
@@ -976,7 +975,8 @@
   }
 }
 
-// The operator == checks for exact equality only (same section, same offset)
+// The operator == checks for exact equality only (same section, same
+// offset)
 bool lldb_private::operator==(const Address &a, const Address &rhs) {
   return a.GetOffset() == rhs.GetOffset() && a.GetSection() == rhs.GetSection();
 }
@@ -992,7 +992,8 @@
   if (module_sp) {
     ObjectFile *obj_file = module_sp->GetObjectFile();
     if (obj_file) {
-      // Give the symbol vendor a chance to add to the unified section list.
+      // Give the symbol vendor a chance to add to the unified section
+      // list.
       module_sp->GetSymbolVendor();
       return obj_file->GetAddressClass(GetFileAddress());
     }
Index: source/Core/AddressResolverFileLine.cpp
===================================================================
--- source/Core/AddressResolverFileLine.cpp
+++ source/Core/AddressResolverFileLine.cpp
@@ -62,8 +62,9 @@
         m_address_ranges.push_back(new_range);
         if (log) {
           StreamString s;
-          // new_bp_loc->GetDescription (&s, lldb::eDescriptionLevelVerbose);
-          // log->Printf ("Added address: %s\n", s.GetData());
+          // new_bp_loc->GetDescription (&s,
+          // lldb::eDescriptionLevelVerbose); log->Printf ("Added address:
+          // %s\n", s.GetData());
         }
       } else {
         if (log)
Index: source/Core/AddressResolverName.cpp
===================================================================
--- source/Core/AddressResolverName.cpp
+++ source/Core/AddressResolverName.cpp
@@ -60,11 +60,9 @@
 AddressResolverName::~AddressResolverName() = default;
 
 // FIXME: Right now we look at the module level, and call the module's
-// "FindFunctions".
-// Greg says he will add function tables, maybe at the CompileUnit level to
-// accelerate function
-// lookup.  At that point, we should switch the depth to CompileUnit, and look
-// in these tables.
+// "FindFunctions". Greg says he will add function tables, maybe at the
+// CompileUnit level to accelerate function lookup.  At that point, we
+// should switch the depth to CompileUnit, and look in these tables.
 
 Searcher::CallbackReturn
 AddressResolverName::SearchCallback(SearchFilter &filter,
Index: source/Core/Broadcaster.cpp
===================================================================
--- source/Core/Broadcaster.cpp
+++ source/Core/Broadcaster.cpp
@@ -74,9 +74,8 @@
 void Broadcaster::BroadcasterImpl::Clear() {
   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
 
-  // Make sure the listener forgets about this broadcaster. We do
-  // this in the broadcaster in case the broadcaster object initiates
-  // the removal.
+  // Make sure the listener forgets about this broadcaster. We do this in
+  // the broadcaster in case the broadcaster object initiates the removal.
   for (auto &pair : GetListeners())
     pair.first->BroadcasterWillDestruct(&m_broadcaster);
 
@@ -142,8 +141,9 @@
     m_listeners.push_back(
         std::make_pair(lldb::ListenerWP(listener_sp), event_mask));
 
-    // Individual broadcasters decide whether they have outstanding data when a
-    // listener attaches, and insert it into the listener with this method.
+    // Individual broadcasters decide whether they have outstanding data
+    // when a listener attaches, and insert it into the listener with this
+    // method.
     m_broadcaster.AddInitialEventsToListener(listener_sp, event_mask);
   }
 
Index: source/Core/Communication.cpp
===================================================================
--- source/Core/Communication.cpp
+++ source/Core/Communication.cpp
@@ -97,16 +97,15 @@
   lldb::ConnectionSP connection_sp(m_connection_sp);
   if (connection_sp) {
     ConnectionStatus status = connection_sp->Disconnect(error_ptr);
-    // We currently don't protect connection_sp with any mutex for
-    // multi-threaded environments. So lets not nuke our connection class
-    // without putting some multi-threaded protections in. We also probably
-    // don't want to pay for the overhead it might cause if every time we
-    // access the connection we have to take a lock.
+    // We currently don't protect connection_sp with any mutex for multi-
+    // threaded environments. So lets not nuke our connection class
+    // without putting some multi-threaded protections in. We also
+    // probably don't want to pay for the overhead it might cause if every
+    // time we access the connection we have to take a lock.
     //
-    // This unique pointer will cleanup after itself when this object goes away,
-    // so there is no need to currently have it destroy itself immediately
-    // upon disconnnect.
-    // connection_sp.reset();
+    // This unique pointer will cleanup after itself when this object goes
+    // away, so there is no need to currently have it destroy itself
+    // immediately upon disconnnect. connection_sp.reset();
     return status;
   }
   return eConnectionStatusNoConnection;
@@ -164,8 +163,8 @@
     return 0;
   }
 
-  // We aren't using a read thread, just read the data synchronously in this
-  // thread.
+  // We aren't using a read thread, just read the data synchronously in
+  // this thread.
   return ReadFromConnection(dst, dst_len, timeout, status, error_ptr);
 }
 
@@ -240,8 +239,8 @@
 size_t Communication::GetCachedBytes(void *dst, size_t dst_len) {
   std::lock_guard<std::recursive_mutex> guard(m_bytes_mutex);
   if (!m_bytes.empty()) {
-    // If DST is nullptr and we have a thread, then return the number
-    // of bytes that are available so the caller can call again
+    // If DST is nullptr and we have a thread, then return the number of
+    // bytes that are available so the caller can call again
     if (dst == nullptr)
       return m_bytes.size();
 
@@ -267,7 +266,8 @@
       (status != lldb::eConnectionStatusEndOfFile))
     return;
   if (m_callback) {
-    // If the user registered a callback, then call it and do not broadcast
+    // If the user registered a callback, then call it and do not
+    // broadcast
     m_callback(m_callback_baton, bytes, len);
   } else if (bytes != nullptr && len > 0) {
     std::lock_guard<std::recursive_mutex> guard(m_bytes_mutex);
@@ -336,9 +336,8 @@
       break;
     case eConnectionStatusInterrupted: // Synchronization signal from
                                        // SynchronizeWithReadThread()
-      // The connection returns eConnectionStatusInterrupted only when there is
-      // no
-      // input pending to be read, so we can signal that.
+      // The connection returns eConnectionStatusInterrupted only when
+      // there is no input pending to be read, so we can signal that.
       comm->BroadcastEvent(eBroadcastBitNoMorePendingInput);
       break;
     case eConnectionStatusNoConnection:   // No connection
Index: source/Core/Debugger.cpp
===================================================================
--- source/Core/Debugger.cpp
+++ source/Core/Debugger.cpp
@@ -167,13 +167,15 @@
   "}${addr-file-or-load}{ "                                                    \
   "<${function.concrete-only-addr-offset-no-padding}>}: "
 
-// gdb's disassembly format can be emulated with
-// ${current-pc-arrow}${addr-file-or-load}{
-// <${function.name-without-args}${function.concrete-only-addr-offset-no-padding}>}:
+// gdb's disassembly format can be emulated with ${current-pc-arrow
+// }${addr-file-or-load}{ <${function.name-without-args}${function
+// .concrete-only-addr-offset-no-padding}>}:
 
-// lldb's original format for disassembly would look like this format string -
-// {${function.initial-function}{${module.file.basename}`}{${function.name-without-args}}:\n}{${function.changed}\n{${module.file.basename}`}{${function.name-without-args}}:\n}{${current-pc-arrow}
-// }{${addr-file-or-load}}:
+// lldb's original format for disassembly would look like this format
+// string - {${function.initial-
+// function}{${module.file.basename}`}{${function.name-without-
+// args}}:\n}{${function.changed}\n{${module.file.basename}`}{${function
+// .name-without-args}}:\n}{${current-pc-arrow} }{${addr-file-or-load}}:
 
 #define DEFAULT_STOP_SHOW_COLUMN_ANSI_PREFIX "${ansi.underline}"
 #define DEFAULT_STOP_SHOW_COLUMN_ANSI_SUFFIX "${ansi.normal}"
@@ -340,8 +342,8 @@
           CommandInterpreter::eBroadcastBitResetPrompt, bytes.release());
       GetCommandInterpreter().BroadcastEvent(prompt_change_event_sp);
     } else if (property_path == g_properties[ePropertyUseColor].name) {
-      // use-color changed. Ping the prompt so it can reset the ansi terminal
-      // codes.
+      // use-color changed. Ping the prompt so it can reset the ansi
+      // terminal codes.
       SetPrompt(GetPrompt());
     } else if (is_load_script && target_sp &&
                load_script_old_value == eLoadScriptFromSymFileWarn) {
@@ -590,9 +592,10 @@
       return true;
     }
   } else {
-    // The g_load_plugin_callback is registered in SBDebugger::Initialize()
-    // and if the public API layer isn't available (code is linking against
-    // all of the internal LLDB static libraries), then we can't load plugins
+    // The g_load_plugin_callback is registered in
+    // SBDebugger::Initialize() and if the public API layer isn't
+    // available (code is linking against all of the internal LLDB static
+    // libraries), then we can't load plugins
     error.SetErrorString("Public API layer is not available");
   }
   return false;
@@ -613,9 +616,9 @@
 
   namespace fs = llvm::sys::fs;
   // If we have a regular file, a symbolic link or unknown file type, try
-  // and process the file. We must handle unknown as sometimes the directory
-  // enumeration might be enumerating a file system that doesn't have correct
-  // file type information.
+  // and process the file. We must handle unknown as sometimes the
+  // directory enumeration might be enumerating a file system that doesn't
+  // have correct file type information.
   if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
       ft == fs::file_type::type_unknown) {
     FileSpec plugin_file_spec(file_spec);
@@ -633,10 +636,10 @@
   } else if (ft == fs::file_type::directory_file ||
              ft == fs::file_type::symlink_file ||
              ft == fs::file_type::type_unknown) {
-    // Try and recurse into anything that a directory or symbolic link.
-    // We must also do this for unknown as sometimes the directory enumeration
-    // might be enumerating a file system that doesn't have correct file type
-    // information.
+    // Try and recurse into anything that a directory or symbolic link. We
+    // must also do this for unknown as sometimes the directory
+    // enumeration might be enumerating a file system that doesn't have
+    // correct file type information.
     return FileSpec::eEnumerateDirectoryResultEnter;
   }
 
@@ -827,9 +830,9 @@
     }
     m_broadcaster_manager_sp->Clear();
 
-    // Close the input file _before_ we close the input read communications
-    // class
-    // as it does NOT own the input file, our m_input_file does.
+    // Close the input file _before_ we close the input read
+    // communications class as it does NOT own the input file, our
+    // m_input_file does.
     m_terminal_state.Clear();
     if (m_input_file_sp)
       m_input_file_sp->GetFile().Close();
@@ -865,8 +868,8 @@
   if (!in_file.IsValid())
     in_file.SetStream(stdin, true);
 
-  // Save away the terminal state if that is relevant, so that we can restore it
-  // in RestoreInputState.
+  // Save away the terminal state if that is relevant, so that we can
+  // restore it in RestoreInputState.
   SaveInputTerminalState();
 }
 
@@ -880,8 +883,9 @@
   if (!out_file.IsValid())
     out_file.SetStream(stdout, false);
 
-  // do not create the ScriptInterpreter just for setting the output file handle
-  // as the constructor will know how to do the right thing on its own
+  // do not create the ScriptInterpreter just for setting the output file
+  // handle as the constructor will know how to do the right thing on its
+  // own
   const bool can_create = false;
   ScriptInterpreter *script_interpreter =
       GetCommandInterpreter().GetScriptInterpreter(can_create);
@@ -946,8 +950,8 @@
 }
 
 void Debugger::ClearIOHandlers() {
-  // The bottom input reader should be the main debugger input reader.  We do
-  // not want to close that one here.
+  // The bottom input reader should be the main debugger input reader.  We
+  // do not want to close that one here.
   std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
   while (m_input_reader_stack.GetSize() > 1) {
     IOHandlerSP reader_sp(m_input_reader_stack.Top());
@@ -1027,11 +1031,11 @@
 void Debugger::AdoptTopIOHandlerFilesIfInvalid(StreamFileSP &in,
                                                StreamFileSP &out,
                                                StreamFileSP &err) {
-  // Before an IOHandler runs, it must have in/out/err streams.
-  // This function is called when one ore more of the streams
-  // are nullptr. We use the top input reader's in/out/err streams,
-  // or fall back to the debugger file handles, or we fall back
-  // onto stdin/stdout/stderr as a last resort.
+  // Before an IOHandler runs, it must have in/out/err streams. This
+  // function is called when one ore more of the streams are nullptr. We
+  // use the top input reader's in/out/err streams, or fall back to the
+  // debugger file handles, or we fall back onto stdin/stdout/stderr as a
+  // last resort.
 
   std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
   IOHandlerSP top_reader_sp(m_input_reader_stack.Top());
@@ -1087,8 +1091,8 @@
   m_input_reader_stack.Push(reader_sp);
   reader_sp->Activate();
 
-  // Interrupt the top input reader to it will exit its Run() function
-  // and let this new input reader take over
+  // Interrupt the top input reader to it will exit its Run() function and
+  // let this new input reader take over
   if (top_reader_sp) {
     top_reader_sp->Deactivate();
     top_reader_sp->Cancel();
@@ -1101,8 +1105,8 @@
 
   std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
 
-  // The reader on the stop of the stack is done, so let the next
-  // read on the stack refresh its prompt and if there is one...
+  // The reader on the stop of the stack is done, so let the next read on
+  // the stack refresh its prompt and if there is one...
   if (m_input_reader_stack.IsEmpty())
     return false;
 
@@ -1198,8 +1202,8 @@
     }
   }
   // The first context on a list of instructions will have a prev_sc that
-  // has no Function or Symbol -- if SymbolContext had an IsValid() method, it
-  // would return false.  But we do get a prev_sc pointer.
+  // has no Function or Symbol -- if SymbolContext had an IsValid()
+  // method, it would return false.  But we do get a prev_sc pointer.
   if ((sc && (sc->function || sc->symbol)) && prev_sc &&
       (prev_sc->function == nullptr && prev_sc->symbol == nullptr)) {
     initial_function = true;
@@ -1210,9 +1214,9 @@
 
 void Debugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
                                   void *baton) {
-  // For simplicity's sake, I am not going to deal with how to close down any
-  // open logging streams, I just redirect everything from here on out to the
-  // callback.
+  // For simplicity's sake, I am not going to deal with how to close down
+  // any open logging streams, I just redirect everything from here on out
+  // to the callback.
   m_log_callback_stream_sp =
       std::make_shared<StreamCallback>(log_callback, baton);
 }
@@ -1227,7 +1231,8 @@
   std::shared_ptr<llvm::raw_ostream> log_stream_sp;
   if (m_log_callback_stream_sp) {
     log_stream_sp = m_log_callback_stream_sp;
-    // For now when using the callback mode you always get thread & timestamp.
+    // For now when using the callback mode you always get thread &
+    // timestamp.
     log_options |=
         LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
   } else if (log_file.empty()) {
@@ -1464,8 +1469,9 @@
 }
 
 void Debugger::HandleThreadEvent(const EventSP &event_sp) {
-  // At present the only thread event we handle is the Frame Changed event,
-  // and all we do for that is just reprint the thread status for that thread.
+  // At present the only thread event we handle is the Frame Changed
+  // event, and all we do for that is just reprint the thread status for
+  // that thread.
   using namespace lldb;
   const uint32_t event_type = event_sp->GetType();
   const bool stop_format = true;
@@ -1518,8 +1524,8 @@
           CommandInterpreter::eBroadcastBitAsynchronousOutputData |
           CommandInterpreter::eBroadcastBitAsynchronousErrorData);
 
-  // Let the thread that spawned us know that we have started up and
-  // that we are now listening to all required events so no events get missed
+  // Let the thread that spawned us know that we have started up and that
+  // we are now listening to all required events so no events get missed
   m_sync_broadcaster.BroadcastEvent(eBroadcastBitEventThreadIsListening);
 
   bool done = false;
@@ -1598,13 +1604,11 @@
         "lldb.debugger.event-handler", EventHandlerThread, this, nullptr,
         g_debugger_event_thread_stack_bytes);
 
-    // Make sure DefaultEventHandler() is running and listening to events before
-    // we return
-    // from this function. We are only listening for events of type
-    // eBroadcastBitEventThreadIsListening so we don't need to check the event,
-    // we just need
-    // to wait an infinite amount of time for it (nullptr timeout as the first
-    // parameter)
+    // Make sure DefaultEventHandler() is running and listening to events
+    // before we return from this function. We are only listening for
+    // events of type eBroadcastBitEventThreadIsListening so we don't need
+    // to check the event, we just need to wait an infinite amount of time
+    // for it (nullptr timeout as the first parameter)
     lldb::EventSP event_sp;
     listener_sp->GetEvent(event_sp, llvm::None);
   }
Index: source/Core/Disassembler.cpp
===================================================================
--- source/Core/Disassembler.cpp
+++ source/Core/Disassembler.cpp
@@ -96,8 +96,8 @@
                                                  const char *plugin_name) {
   if (target_sp && flavor == nullptr) {
     // FIXME - we don't have the mechanism in place to do per-architecture
-    // settings.  But since we know that for now
-    // we only support flavors on x86 & x86_64,
+    // settings.  But since we know that for now we only support flavors
+    // on x86 & x86_64,
     if (arch.GetTriple().getArch() == llvm::Triple::x86 ||
         arch.GetTriple().getArch() == llvm::Triple::x86_64)
       flavor = target_sp->GetDisassemblyFlavor();
@@ -108,8 +108,8 @@
 static void ResolveAddress(const ExecutionContext &exe_ctx, const Address &addr,
                            Address &resolved_addr) {
   if (!addr.IsSectionOffset()) {
-    // If we weren't passed in a section offset address range,
-    // try and resolve it to something
+    // If we weren't passed in a section offset address range, try and
+    // resolve it to something
     Target *target = exe_ctx.GetTargetPtr();
     if (target) {
       if (target->GetSectionLoadList().IsEmpty()) {
@@ -118,8 +118,8 @@
         target->GetSectionLoadList().ResolveLoadAddress(addr.GetOffset(),
                                                         resolved_addr);
       }
-      // We weren't able to resolve the address, just treat it as a
-      // raw address
+      // We weren't able to resolve the address, just treat it as a raw
+      // address
       if (resolved_addr.IsValid())
         return;
     }
@@ -327,7 +327,8 @@
     const ExecutionContext &exe_ctx, const SymbolContext &sc,
     SourceLine &line) {
 
-  // TODO: should we also check target.process.thread.step-avoid-libraries ?
+  // TODO: should we also check target.process.thread.step-avoid-libraries
+  // ?
 
   const RegularExpression *avoid_regex = nullptr;
 
@@ -410,15 +411,13 @@
     disassembly_format = &format;
   }
 
-  // First pass: step through the list of instructions,
-  // find how long the initial addresses strings are, insert padding
-  // in the second pass so the opcodes all line up nicely.
+  // First pass: step through the list of instructions, find how long the
+  // initial addresses strings are, insert padding in the second pass so
+  // the opcodes all line up nicely.
 
-  // Also build up the source line mapping if this is mixed source & assembly
-  // mode.
-  // Calculate the source line for each assembly instruction (eliding inlined
-  // functions
-  // which the user wants to skip).
+  // Also build up the source line mapping if this is mixed source &
+  // assembly mode. Calculate the source line for each assembly
+  // instruction (eliding inlined functions which the user wants to skip).
 
   std::map<FileSpec, std::set<uint32_t>> source_lines_seen;
   Symbol *previous_symbol = nullptr;
@@ -444,12 +443,12 @@
           if (cur_line > address_text_size)
             address_text_size = cur_line;
 
-          // Add entries to our "source_lines_seen" map+set which list which
-          // sources lines occur in this disassembly session.  We will print
-          // lines of context around a source line, but we don't want to print
-          // a source line that has a line table entry of its own - we'll leave
-          // that source line to be printed when it actually occurs in the
-          // disassembly.
+          // Add entries to our "source_lines_seen" map+set which list
+          // which sources lines occur in this disassembly session.  We
+          // will print lines of context around a source line, but we
+          // don't want to print a source line that has a line table entry
+          // of its own - we'll leave that source line to be printed when
+          // it actually occurs in the disassembly.
 
           if (mixed_source_and_assembly && sc.line_entry.IsValid()) {
             if (sc.symbol != previous_symbol) {
@@ -494,18 +493,16 @@
         if (resolved_mask) {
           if (mixed_source_and_assembly) {
 
-            // If we've started a new function (non-inlined), print all of the
-            // source lines from the
-            // function declaration until the first line table entry - typically
-            // the opening curly brace of
-            // the function.
+            // If we've started a new function (non-inlined), print all of
+            // the source lines from the function declaration until the
+            // first line table entry - typically the opening curly brace
+            // of the function.
             if (previous_symbol != sc.symbol) {
-              // The default disassembly format puts an extra blank line between
-              // functions - so
-              // when we're displaying the source context for a function, we
-              // don't want to add
-              // a blank line after the source context or we'll end up with two
-              // of them.
+              // The default disassembly format puts an extra blank line
+              // between functions - so when we're displaying the source
+              // context for a function, we don't want to add a blank line
+              // after the source context or we'll end up with two of
+              // them.
               if (previous_symbol != nullptr)
                 source_lines_to_display.print_source_context_end_eol = false;
 
@@ -542,8 +539,8 @@
                                  current_source_line_range);
             }
 
-            // If we've left a previous source line's address range, print a new
-            // source line
+            // If we've left a previous source line's address range, print
+            // a new source line
             if (!current_source_line_range.ContainsFileAddress(addr)) {
               sc.GetAddressRange(scope, 0, use_inline_block_range,
                                  current_source_line_range);
@@ -555,11 +552,11 @@
 
                 if (ElideMixedSourceAndDisassemblyLine(exe_ctx, sc,
                                                        this_line) == false) {
-                  // Only print this source line if it is different from the
-                  // last source line we printed.  There may have been inlined
-                  // functions between these lines that we elided, resulting in
-                  // the same line being printed twice in a row for a contiguous
-                  // block of assembly instructions.
+                  // Only print this source line if it is different from
+                  // the last source line we printed.  There may have been
+                  // inlined functions between these lines that we elided,
+                  // resulting in the same line being printed twice in a
+                  // row for a contiguous block of assembly instructions.
                   if (this_line != previous_line) {
 
                     std::vector<uint32_t> previous_lines;
@@ -710,9 +707,9 @@
 
   if (show_bytes) {
     if (m_opcode.GetType() == Opcode::eTypeBytes) {
-      // x86_64 and i386 are the only ones that use bytes right now so
-      // pad out the byte dump to be able to always show 15 bytes (3 chars each)
-      // plus a space
+      // x86_64 and i386 are the only ones that use bytes right now so pad
+      // out the byte dump to be able to always show 15 bytes (3 chars
+      // each) plus a space
       if (max_opcode_byte_size > 0)
         m_opcode.Dump(&ss, max_opcode_byte_size * 3 + 1);
       else
@@ -729,9 +726,10 @@
 
   const size_t opcode_pos = ss.GetSizeOfLastLine();
 
-  // The default opcode size of 7 characters is plenty for most architectures
-  // but some like arm can pull out the occasional vqrshrun.s16.  We won't get
-  // consistent column spacing in these cases, unfortunately.
+  // The default opcode size of 7 characters is plenty for most
+  // architectures but some like arm can pull out the occasional
+  // vqrshrun.s16.  We won't get consistent column spacing in these cases,
+  // unfortunately.
   if (m_opcode_name.length() >= opcode_column_width) {
     opcode_column_width = m_opcode_name.length() + 1;
   }
@@ -846,7 +844,8 @@
       return option_value_sp;
     }
 
-    // Check to see if the line contains the end-of-dictionary marker ("}")
+    // Check to see if the line contains the end-of-dictionary marker
+    // ("}")
     std::string line(buffer);
 
     size_t len = line.size();
@@ -903,7 +902,8 @@
           option_value_sp.reset();
           return option_value_sp;
         }
-        // We've used the data_type to read an array; re-set the type to Invalid
+        // We've used the data_type to read an array; re-set the type to
+        // Invalid
         data_type = OptionValue::eTypeInvalid;
       } else if ((value[0] == '0') && (value[1] == 'x')) {
         value_sp = std::make_shared<OptionValueUInt64>(0, 0);
@@ -916,10 +916,9 @@
       }
 
       if (const_key == encoding_key) {
-        // A 'data_encoding=..." is NOT a normal key-value pair; it is meta-data
-        // indicating the
-        // data type of an upcoming array (usually the next bit of data to be
-        // read in).
+        // A 'data_encoding=..." is NOT a normal key-value pair; it is
+        // meta-data indicating the data type of an upcoming array
+        // (usually the next bit of data to be read in).
         if (strcmp(value.c_str(), "uint32_t") == 0)
           data_type = OptionValue::eTypeUInt64;
       } else
@@ -1107,9 +1106,9 @@
     }
   }
 
-  // Hexagon needs the first instruction of the packet with the branch.
-  // Go backwards until we find an instruction marked end-of-packet, or
-  // until we hit start.
+  // Hexagon needs the first instruction of the packet with the branch. Go
+  // backwards until we find an instruction marked end-of-packet, or until
+  // we hit start.
   if (target.GetArchitecture().GetTriple().getArch() == llvm::Triple::hexagon) {
     // If we didn't find a branch, find the last packet start.
     if (next_branch == UINT32_MAX) {
@@ -1128,8 +1127,8 @@
       // If we have an error reading memory, return start
       if (!error.Success())
         return start;
-      // check if this is the last instruction in a packet
-      // bits 15:14 will be 11b or 00b for a duplex
+      // check if this is the last instruction in a packet bits 15:14 will
+      // be 11b or 00b for a duplex
       if (((inst_bytes & 0xC000) == 0xC000) ||
           ((inst_bytes & 0xC000) == 0x0000)) {
         // instruction after this should be the start of next packet
Index: source/Core/DumpDataExtractor.cpp
===================================================================
--- source/Core/DumpDataExtractor.cpp
+++ source/Core/DumpDataExtractor.cpp
@@ -328,7 +328,8 @@
         s->PutChar(NON_PRINTABLE_CHAR);
       }
 
-      // If we are only printing one character surround it with single quotes
+      // If we are only printing one character surround it with single
+      // quotes
       if (item_count == 1 && item_format == eFormatChar)
         s->PutChar('\'');
     } break;
@@ -693,9 +694,8 @@
       break;
 
     // please keep the single-item formats below in sync with
-    // FormatManager::GetSingleItemFormat
-    // if you fail to do so, users will start getting different outputs
-    // depending on internal
+    // FormatManager::GetSingleItemFormat if you fail to do so, users will
+    // start getting different outputs depending on internal
     // implementation details they should not care about ||
     case eFormatVectorOfChar: //   ||
       s->PutChar('{');        //   \/
Index: source/Core/DynamicLoader.cpp
===================================================================
--- source/Core/DynamicLoader.cpp
+++ source/Core/DynamicLoader.cpp
@@ -86,8 +86,8 @@
                              executable->GetArchitecture());
       auto module_sp = std::make_shared<Module>(module_spec);
 
-      // Check if the executable has changed and set it to the target executable
-      // if they differ.
+      // Check if the executable has changed and set it to the target
+      // executable if they differ.
       if (module_sp && module_sp->GetUUID().IsValid() &&
           executable->GetUUID().IsValid()) {
         if (module_sp->GetUUID() != executable->GetUUID())
@@ -99,8 +99,8 @@
       if (!executable) {
         executable = target.GetSharedModule(module_spec);
         if (executable.get() != target.GetExecutableModulePointer()) {
-          // Don't load dependent images since we are in dyld where we will know
-          // and find out about all images that are loaded
+          // Don't load dependent images since we are in dyld where we
+          // will know and find out about all images that are loaded
           const bool get_dependent_images = false;
           target.SetExecutableModule(executable, get_dependent_images);
         }
@@ -176,9 +176,9 @@
 
   bool check_alternative_file_name = true;
   if (base_addr_is_offset) {
-    // Try to fetch the load address of the file from the process as we need
-    // absolute load
-    // address to read the file out of the memory instead of a load bias.
+    // Try to fetch the load address of the file from the process as we
+    // need absolute load address to read the file out of the memory
+    // instead of a load bias.
     bool is_loaded = false;
     lldb::addr_t load_addr;
     Status error = m_process->GetFileLoadAddress(file, is_loaded, load_addr);
@@ -188,9 +188,8 @@
     }
   }
 
-  // We failed to find the module based on its name. Lets try to check if we can
-  // find a
-  // different name based on the memory region info.
+  // We failed to find the module based on its name. Lets try to check if
+  // we can find a different name based on the memory region info.
   if (check_alternative_file_name) {
     MemoryRegionInfo memory_info;
     Status error = m_process->GetMemoryRegionInfo(base_addr, memory_info);
Index: source/Core/FileSpecList.cpp
===================================================================
--- source/Core/FileSpecList.cpp
+++ source/Core/FileSpecList.cpp
@@ -42,8 +42,7 @@
 }
 
 //------------------------------------------------------------------
-// Only append the "file_spec" if this list doesn't already contain
-// it.
+// Only append the "file_spec" if this list doesn't already contain it.
 //
 // Returns true if "file_spec" was added, false if this list already
 // contained a copy of "file_spec".
@@ -78,8 +77,8 @@
 // Find the index of the file in the file spec list that matches
 // "file_spec" starting "start_idx" entries into the file spec list.
 //
-// Returns the valid index of the file that matches "file_spec" if
-// it is found, else std::numeric_limits<uint32_t>::max() is returned.
+// Returns the valid index of the file that matches "file_spec" if it is
+// found, else std::numeric_limits<uint32_t>::max() is returned.
 //------------------------------------------------------------------
 size_t FileSpecList::FindFileIndex(size_t start_idx, const FileSpec &file_spec,
                                    bool full, bool remove_dots) const {
@@ -106,8 +105,8 @@
 }
 
 //------------------------------------------------------------------
-// Returns the FileSpec object at index "idx". If "idx" is out of
-// range, then an empty FileSpec object will be returned.
+// Returns the FileSpec object at index "idx". If "idx" is out of range,
+// then an empty FileSpec object will be returned.
 //------------------------------------------------------------------
 const FileSpec &FileSpecList::GetFileSpecAtIndex(size_t idx) const {
   if (idx < m_files.size())
@@ -123,11 +122,11 @@
 }
 
 //------------------------------------------------------------------
-// Return the size in bytes that this object takes in memory. This
-// returns the size in bytes of this object's member variables and
-// any FileSpec objects its member variables contain, the result
-// doesn't not include the string values for the directories any
-// filenames as those are in shared string pools.
+// Return the size in bytes that this object takes in memory. This returns
+// the size in bytes of this object's member variables and any FileSpec
+// objects its member variables contain, the result doesn't not include
+// the string values for the directories any filenames as those are in
+// shared string pools.
 //------------------------------------------------------------------
 size_t FileSpecList::MemorySize() const {
   size_t mem_size = sizeof(FileSpecList);
Index: source/Core/FormatEntity.cpp
===================================================================
--- source/Core/FormatEntity.cpp
+++ source/Core/FormatEntity.cpp
@@ -467,10 +467,9 @@
       if (sc->function) {
         func_addr = sc->function->GetAddressRange().GetBaseAddress();
         if (sc->block && !concrete_only) {
-          // Check to make sure we aren't in an inline
-          // function. If we are, use the inline block
-          // range that contains "format_addr" since
-          // blocks can be discontiguous.
+          // Check to make sure we aren't in an inline function. If we
+          // are, use the inline block range that contains "format_addr"
+          // since blocks can be discontiguous.
           Block *inline_block = sc->block->GetContainingInlinedBlock();
           AddressRange inline_range;
           if (inline_block &&
@@ -822,8 +821,7 @@
   if (do_deref_pointer && !is_array_range) {
     // I have not deref-ed yet, let's do it
     // this happens when we are not going through
-    // GetValueForVariableExpressionPath
-    // to get to the target ValueObject
+    // GetValueForVariableExpressionPath to get to the target ValueObject
     Status error;
     target = target->Dereference(error).get();
     if (error.Fail()) {
@@ -842,11 +840,12 @@
     return false;
   }
 
-  // we do not want to use the summary for a bitfield of type T:n
-  // if we were originally dealing with just a T - that would get
-  // us into an endless recursion
+  // we do not want to use the summary for a bitfield of type T:n if we
+  // were originally dealing with just a T - that would get us into an
+  // endless recursion
   if (target->IsBitfield() && was_var_indexed) {
-    // TODO: check for a (T:n)-specific summary - we should still obey that
+    // TODO: check for a (T:n)-specific summary - we should still obey
+    // that
     StreamString bitfield_name;
     bitfield_name.Printf("%s:%d", target->GetTypeName().AsCString(),
                          target->GetBitfieldBitSize());
@@ -904,16 +903,15 @@
     }
   }
 
-  // if directly trying to print ${var}, and this is an aggregate, display a
-  // nice
-  // type @ location message
+  // if directly trying to print ${var}, and this is an aggregate, display
+  // a nice type @ location message
   if (is_aggregate && was_plain_var) {
     s << target->GetTypeName() << " @ " << target->GetLocationAsCString();
     return true;
   }
 
-  // if directly trying to print ${var%V}, and this is an aggregate, do not let
-  // the user do it
+  // if directly trying to print ${var%V}, and this is an aggregate, do
+  // not let the user do it
   if (is_aggregate &&
       ((was_var_format &&
         val_obj_display ==
@@ -1113,11 +1111,14 @@
   switch (entry.type) {
   case Entry::Type::Invalid:
   case Entry::Type::ParentNumber: // Only used for
-                                  // FormatEntity::Entry::Definition encoding
+                                  // FormatEntity::Entry::Definition
+                                  // encoding
   case Entry::Type::ParentString: // Only used for
-                                  // FormatEntity::Entry::Definition encoding
+                                  // FormatEntity::Entry::Definition
+                                  // encoding
   case Entry::Type::InsertString: // Only used for
-                                  // FormatEntity::Entry::Definition encoding
+                                  // FormatEntity::Entry::Definition
+                                  // encoding
     return false;
 
   case Entry::Type::Root:
@@ -1142,8 +1143,8 @@
       if (!success)
         break;
     }
-    // Only if all items in a scope succeed, then do we
-    // print the output into the main stream
+    // Only if all items in a scope succeed, then do we print the output
+    // into the main stream
     if (success)
       s.Write(scope_stream.GetString().data(), scope_stream.GetString().size());
   }
@@ -1206,9 +1207,9 @@
           // Watch for the special "tid" format...
           if (entry.printf_format == "tid") {
             // TODO(zturner): Rather than hardcoding this to be platform
-            // specific, it should be controlled by a
-            // setting and the default value of the setting can be different
-            // depending on the platform.
+            // specific, it should be controlled by a setting and the
+            // default value of the setting can be different depending on
+            // the platform.
             Target &target = thread->GetProcess()->GetTarget();
             ArchSpec arch(target.GetArchitecture());
             llvm::Triple::OSType ostype = arch.IsValid()
@@ -1644,9 +1645,9 @@
             const char *open_paren = strchr(cstr, '(');
             const char *close_paren = nullptr;
             const char *generic = strchr(cstr, '<');
-            // if before the arguments list begins there is a template sign
-            // then scan to the end of the generic args before you try to find
-            // the arguments list
+            // if before the arguments list begins there is a template
+            // sign then scan to the end of the generic args before you
+            // try to find the arguments list
             if (generic && open_paren && generic < open_paren) {
               int generic_depth = 1;
               ++generic;
@@ -1913,10 +1914,10 @@
             DumpCommaSeparatedChildEntryNames(error_strm, entry_def);
             error.SetErrorStringWithFormat("%s", error_strm.GetData());
           } else if (sep_char == ':') {
-            // Any value whose separator is a with a ':' means this value has a
-            // string argument
-            // that needs to be stored in the entry (like "${script.var:}").
-            // In this case the string value is the empty string which is ok.
+            // Any value whose separator is a with a ':' means this value
+            // has a string argument that needs to be stored in the entry
+            // (like "${script.var:}"). In this case the string value is
+            // the empty string which is ok.
           } else {
             error.SetErrorStringWithFormat("%s", "invalid entry definitions");
           }
@@ -1925,10 +1926,9 @@
         if (entry_def->children) {
           error = ParseEntry(value, entry_def, entry);
         } else if (sep_char == ':') {
-          // Any value whose separator is a with a ':' means this value has a
-          // string argument
-          // that needs to be stored in the entry (like
-          // "${script.var:modulename.function}")
+          // Any value whose separator is a with a ':' means this value
+          // has a string argument that needs to be stored in the entry
+          // (like "${script.var:modulename.function}")
           entry.string = value.str();
         } else {
           error.SetErrorStringWithFormat(
@@ -1990,14 +1990,15 @@
     const size_t non_special_chars = format.find_first_of("${}\\");
 
     if (non_special_chars == llvm::StringRef::npos) {
-      // No special characters, just string bytes so add them and we are done
+      // No special characters, just string bytes so add them and we are
+      // done
       parent_entry.AppendText(format);
       return error;
     }
 
     if (non_special_chars > 0) {
-      // We have a special character, so add all characters before these as a
-      // plain string
+      // We have a special character, so add all characters before these
+      // as a plain string
       parent_entry.AppendText(format.substr(0, non_special_chars));
       format = format.drop_front(non_special_chars);
     }
@@ -2065,17 +2066,17 @@
       case '0':
         // 1 to 3 octal chars
         {
-          // Make a string that can hold onto the initial zero char,
-          // up to 3 octal digits, and a terminating NULL.
+          // Make a string that can hold onto the initial zero char, up to
+          // 3 octal digits, and a terminating NULL.
           char oct_str[5] = {0, 0, 0, 0, 0};
 
           int i;
           for (i = 0; (format[i] >= '0' && format[i] <= '7') && i < 4; ++i)
             oct_str[i] = format[i];
 
-          // We don't want to consume the last octal character since
-          // the main for loop will do this for us, so we advance p by
-          // one less than i (even if i is zero)
+          // We don't want to consume the last octal character since the
+          // main for loop will do this for us, so we advance p by one
+          // less than i (even if i is zero)
           format = format.drop_front(i);
           unsigned long octal_value = ::strtoul(oct_str, nullptr, 8);
           if (octal_value <= UINT8_MAX) {
@@ -2090,8 +2091,8 @@
       case 'x':
         // hex number in the format
         if (isxdigit(format[0])) {
-          // Make a string that can hold onto two hex chars plus a
-          // NULL terminator
+          // Make a string that can hold onto two hex chars plus a NULL
+          // terminator
           char hex_str[3] = {0, 0, 0};
           hex_str[0] = format[0];
 
@@ -2115,8 +2116,8 @@
         break;
 
       default:
-        // Just desensitize any other character by just printing what
-        // came after the '\'
+        // Just desensitize any other character by just printing what came
+        // after the '\'
         parent_entry.AppendChar(desens_char);
         break;
       }
@@ -2143,13 +2144,12 @@
             entry.printf_format = variable_format.str();
 
             // If the format contains a '%' we are going to assume this is
-            // a printf style format. So if you want to format your thread ID
-            // using "0x%llx" you can use:
-            // ${thread.id%0x%llx}
+            // a printf style format. So if you want to format your thread
+            // ID using "0x%llx" you can use: ${thread.id%0x%llx}
             //
-            // If there is no '%' in the format, then it is assumed to be a
-            // LLDB format name, or one of the extended formats specified in
-            // the switch statement below.
+            // If there is no '%' in the format, then it is assumed to be
+            // a LLDB format name, or one of the extended formats
+            // specified in the switch statement below.
 
             if (entry.printf_format.find('%') == std::string::npos) {
               bool clear_printf = false;
@@ -2217,8 +2217,8 @@
                 return error;
               }
 
-              // Our format string turned out to not be a printf style format
-              // so lets clear the string
+              // Our format string turned out to not be a printf style
+              // format so lets clear the string
               if (clear_printf)
                 entry.printf_format.clear();
             }
@@ -2255,8 +2255,8 @@
             }
             break;
           default:
-            // Make sure someone didn't try to dereference anything but ${var}
-            // or ${svar}
+            // Make sure someone didn't try to dereference anything but
+            // ${var} or ${svar}
             if (entry.deref) {
               error.SetErrorStringWithFormat(
                   "${%s} can't be dereferenced, only ${var} and ${svar} can.",
Index: source/Core/IOHandler.cpp
===================================================================
--- source/Core/IOHandler.cpp
+++ source/Core/IOHandler.cpp
@@ -91,7 +91,8 @@
     : m_debugger(debugger), m_input_sp(input_sp), m_output_sp(output_sp),
       m_error_sp(error_sp), m_popped(false), m_flags(flags), m_type(type),
       m_user_data(nullptr), m_done(false), m_active(false) {
-  // If any files are not specified, then adopt them from the top input reader.
+  // If any files are not specified, then adopt them from the top input
+  // reader.
   if (!m_input_sp || !m_output_sp || !m_error_sp)
     debugger.AdoptTopIOHandlerFilesIfInvalid(m_input_sp, m_output_sp,
                                              m_error_sp);
@@ -256,8 +257,8 @@
       matches.LongestCommonPrefix(common_prefix);
       const size_t partial_name_len = strlen(word_start);
 
-      // If we matched a unique single command, add a space...
-      // Only do this if the completer told us this was a complete word,
+      // If we matched a unique single command, add a space... Only do
+      // this if the completer told us this was a complete word,
       // however...
       if (num_matches == 1 && word_complete) {
         common_prefix.push_back(' ');
@@ -321,8 +322,8 @@
     const char *indent_chars = delegate.IOHandlerGetFixIndentationCharacters();
     if (indent_chars) {
       // The delegate does support indentation, hook it up so when any
-      // indentation
-      // character is typed, the delegate gets a chance to fix it
+      // indentation character is typed, the delegate gets a chance to fix
+      // it
       m_editline_ap->SetFixIndentationCallback(FixIndentationCallback, this,
                                                indent_chars);
     }
@@ -408,8 +409,8 @@
         }
       }
       m_editing = false;
-      // We might have gotten a newline on a line by itself
-      // make sure to return true in this case.
+      // We might have gotten a newline on a line by itself make sure to
+      // return true in this case.
       return got_line;
     } else {
       // No more input file, we are done...
@@ -545,9 +546,8 @@
   return success;
 }
 
-// Each IOHandler gets to run until it is done. It should read data
-// from the "in" and place output into "out" and "err and return
-// when done.
+// Each IOHandler gets to run until it is done. It should read data from
+// the "in" and place output into "out" and "err and return when done.
 void IOHandlerEditline::Run() {
   std::string line;
   while (IsActive()) {
@@ -635,8 +635,7 @@
   }
 }
 
-// we may want curses to be disabled for some builds
-// for instance, windows
+// we may want curses to be disabled for some builds for instance, windows
 #ifndef LLDB_DISABLE_CURSES
 
 #define KEY_RETURN 10
@@ -738,9 +737,9 @@
     origin.y += h;
   }
 
-  // Return a status bar rectangle which is the last line of
-  // this rectangle. This rectangle will be modified to not
-  // include the status bar area.
+  // Return a status bar rectangle which is the last line of this
+  // rectangle. This rectangle will be modified to not include the status
+  // bar area.
   Rect MakeStatusBar() {
     Rect status_bar;
     if (size.height > 1) {
@@ -753,9 +752,8 @@
     return status_bar;
   }
 
-  // Return a menubar rectangle which is the first line of
-  // this rectangle. This rectangle will be modified to not
-  // include the menubar area.
+  // Return a menubar rectangle which is the first line of this rectangle.
+  // This rectangle will be modified to not include the menubar area.
   Rect MakeMenuBar() {
     Rect menubar;
     if (size.height > 1) {
@@ -1204,12 +1202,10 @@
         return result;
     }
 
-    // Then check for any windows that want any keys
-    // that weren't handled. This is typically only
-    // for a menubar.
-    // Make a copy of the subwindows in case any HandleChar()
-    // functions muck with the subwindows. If we don't do this,
-    // we can crash when iterating over the subwindows.
+    // Then check for any windows that want any keys that weren't handled.
+    // This is typically only for a menubar. Make a copy of the subwindows
+    // in case any HandleChar() functions muck with the subwindows. If we
+    // don't do this, we can crash when iterating over the subwindows.
     Windows subwindows(m_subwindows);
     for (auto subwindow_sp : subwindows) {
       if (!subwindow_sp->m_can_activate) {
@@ -1245,7 +1241,8 @@
           m_prev_active_window_idx = UINT32_MAX;
           m_curr_active_window_idx = UINT32_MAX;
 
-          // Find first window that wants to be active if this window is active
+          // Find first window that wants to be active if this window is
+          // active
           const size_t num_subwindows = m_subwindows.size();
           for (size_t i = 0; i < num_subwindows; ++i) {
             if (m_subwindows[i]->GetCanBeActive()) {
@@ -1396,8 +1393,8 @@
   }
 
   MenuActionResult Action() {
-    // Call the recursive action so it can try to handle it
-    // with the menu delegate, and if not, try our parent menu
+    // Call the recursive action so it can try to handle it with the menu
+    // delegate, and if not, try our parent menu
     return ActionPrivate(*this);
   }
 
@@ -1666,9 +1663,9 @@
     }
 
     if (run_menu_sp) {
-      // Run the action on this menu in case we need to populate the
-      // menu with dynamic content and also in case check marks, and
-      // any other menu decorations need to be calculated
+      // Run the action on this menu in case we need to populate the menu
+      // with dynamic content and also in case check marks, and any other
+      // menu decorations need to be calculated
       if (run_menu_sp->Action() == MenuActionResult::Quit)
         return eQuitApplication;
 
@@ -1784,10 +1781,10 @@
 
     // Alas the threading model in curses is a bit lame so we need to
     // resort to polling every 0.5 seconds. We could poll for stdin
-    // ourselves and then pass the keys down but then we need to
-    // translate all of the escape sequences ourselves. So we resort to
-    // polling for input because we need to receive async process events
-    // while in this loop.
+    // ourselves and then pass the keys down but then we need to translate
+    // all of the escape sequences ourselves. So we resort to polling for
+    // input because we need to receive async process events while in this
+    // loop.
 
     halfdelay(delay_in_tenths_of_a_second); // Poll using some number of tenths
                                             // of seconds seconds when calling
@@ -1809,12 +1806,12 @@
       if (update) {
         m_window_sp->Draw(false);
         // All windows should be calling Window::DeferredRefresh() instead
-        // of Window::Refresh() so we can do a single update and avoid
-        // any screen blinking
+        // of Window::Refresh() so we can do a single update and avoid any
+        // screen blinking
         update_panels();
 
-        // Cursor hiding isn't working on MacOSX, so hide it in the top left
-        // corner
+        // Cursor hiding isn't working on MacOSX, so hide it in the top
+        // left corner
         m_window_sp->MoveCursor(0, 0);
 
         doupdate();
@@ -1822,9 +1819,9 @@
       }
 
 #if defined(__APPLE__)
-      // Terminal.app doesn't map its function keys correctly, F1-F4 default to:
-      // \033OP, \033OQ, \033OR, \033OS, so lets take care of this here if
-      // possible
+      // Terminal.app doesn't map its function keys correctly, F1-F4
+      // default to: \033OP, \033OQ, \033OR, \033OS, so lets take care of
+      // this here if possible
       int ch;
       if (escape_chars.empty())
         ch = m_window_sp->GetChar();
@@ -1986,8 +1983,8 @@
       parent->DrawTreeForChild(window, this, 0);
 
     if (might_have_children) {
-      // It we can get UTF8 characters to work we should try to use the "symbol"
-      // UTF8 string below
+      // It we can get UTF8 characters to work we should try to use the
+      // "symbol" UTF8 string below
       //            const char *symbol = "";
       //            if (row.expanded)
       //                symbol = "\xe2\x96\xbd ";
@@ -1995,8 +1992,8 @@
       //                symbol = "\xe2\x96\xb7 ";
       //            window.PutCString (symbol);
 
-      // The ACS_DARROW and ACS_RARROW don't look very nice they are just a
-      // 'v' or '>' character...
+      // The ACS_DARROW and ACS_RARROW don't look very nice they are just
+      // a 'v' or '>' character...
       //            if (expanded)
       //                window.PutChar (ACS_DARROW);
       //            else
@@ -2102,9 +2099,8 @@
 
     const bool expanded = IsExpanded();
 
-    // The root item must calculate its children,
-    // or we must calculate the number of children
-    // if the item is expanded
+    // The root item must calculate its children, or we must calculate the
+    // number of children if the item is expanded
     if (m_parent == nullptr || expanded)
       GetNumChildren();
 
@@ -2137,8 +2133,7 @@
 
       if (m_might_have_children) {
         // It we can get UTF8 characters to work we should try to use the
-        // "symbol"
-        // UTF8 string below
+        // "symbol" UTF8 string below
         //            const char *symbol = "";
         //            if (row.expanded)
         //                symbol = "\xe2\x96\xbd ";
@@ -2146,8 +2141,8 @@
         //                symbol = "\xe2\x96\xb7 ";
         //            window.PutCString (symbol);
 
-        // The ACS_DARROW and ACS_RARROW don't look very nice they are just a
-        // 'v' or '>' character...
+        // The ACS_DARROW and ACS_RARROW don't look very nice they are
+        // just a 'v' or '>' character...
         //            if (expanded)
         //                window.PutChar (ACS_DARROW);
         //            else
@@ -2176,8 +2171,8 @@
 
     if (IsExpanded()) {
       for (auto &item : m_children) {
-        // If we displayed all the rows and item.Draw() returns
-        // false we are done drawing and can exit this for loop
+        // If we displayed all the rows and item.Draw() returns false we
+        // are done drawing and can exit this for loop
         if (!item.Draw(window, first_visible_row, selected_row_idx, row_idx,
                        num_rows_left))
           break;
@@ -2287,10 +2282,9 @@
       m_num_rows = 0;
       m_root.CalculateRowIndexes(m_num_rows);
 
-      // If we unexpanded while having something selected our
-      // total number of rows is less than the num visible rows,
-      // then make sure we show all the rows by setting the first
-      // visible row accordingly.
+      // If we unexpanded while having something selected our total number
+      // of rows is less than the num visible rows, then make sure we show
+      // all the rows by setting the first visible row accordingly.
       if (m_first_visible_row > 0 && m_num_rows < num_visible_rows)
         m_first_visible_row = 0;
 
@@ -2696,10 +2690,9 @@
     const int num_visible_rows = NumVisibleRows();
     const int num_rows = CalculateTotalNumberRows(m_rows);
 
-    // If we unexpanded while having something selected our
-    // total number of rows is less than the num visible rows,
-    // then make sure we show all the rows by setting the first
-    // visible row accordingly.
+    // If we unexpanded while having something selected our total number
+    // of rows is less than the num visible rows, then make sure we show
+    // all the rows by setting the first visible row accordingly.
     if (m_first_visible_row > 0 && num_rows < num_visible_rows)
       m_first_visible_row = 0;
 
@@ -3128,8 +3121,8 @@
       if (process && process->IsAlive())
         return true; // Don't do any updating if we are running
       else {
-        // Update the values with an empty list if there
-        // is no process or the process isn't alive anymore
+        // Update the values with an empty list if there is no process or
+        // the process isn't alive anymore
         SetValues(value_list);
       }
     }
@@ -3393,8 +3386,8 @@
 
   if (num_lines <= num_visible_lines) {
     done = true;
-    // If we have all lines visible and don't need scrolling, then any
-    // key press will cause us to exit
+    // If we have all lines visible and don't need scrolling, then any key
+    // press will cause us to exit
   } else {
     switch (key) {
     case KEY_UP:
@@ -3606,9 +3599,9 @@
       return MenuActionResult::Handled;
 
     case eMenuID_Process: {
-      // Populate the menu with all of the threads if the process is stopped
-      // when
-      // the Process menu gets selected and is about to display its submenu.
+      // Populate the menu with all of the threads if the process is
+      // stopped when the Process menu gets selected and is about to
+      // display its submenu.
       Menus &submenus = menu.GetSubmenus();
       ExecutionContext exe_ctx =
           m_debugger.GetCommandInterpreter().GetExecutionContext();
@@ -3643,12 +3636,12 @@
                               nullptr, menu_char, thread_sp->GetID())));
         }
       } else if (submenus.size() > 7) {
-        // Remove the separator and any other thread submenu items
-        // that were previously added
+        // Remove the separator and any other thread submenu items that
+        // were previously added
         submenus.erase(submenus.begin() + 7, submenus.end());
       }
-      // Since we are adding and removing items we need to recalculate the name
-      // lengths
+      // Since we are adding and removing items we need to recalculate the
+      // name lengths
       menu.RecalculateNameLengths();
     }
       return MenuActionResult::Handled;
@@ -3672,8 +3665,8 @@
           registers_bounds.size.width = source_bounds.size.width;
           registers_window_sp->SetBounds(registers_bounds);
         } else {
-          // We have no registers window showing so give the bottom
-          // area back to the source view
+          // We have no registers window showing so give the bottom area
+          // back to the source view
           source_window_sp->Resize(source_bounds.size.width,
                                    source_bounds.size.height +
                                        variables_bounds.size.height);
@@ -3690,7 +3683,8 @@
                                                    new_registers_rect);
           registers_window_sp->SetBounds(new_registers_rect);
         } else {
-          // No variables window, grab the bottom part of the source window
+          // No variables window, grab the bottom part of the source
+          // window
           Rect new_source_rect;
           source_bounds.HorizontalSplitPercentage(0.70, new_source_rect,
                                                   new_variables_rect);
@@ -3722,8 +3716,8 @@
                                           registers_window_sp->GetWidth(),
                                       variables_bounds.size.height);
         } else {
-          // We have no variables window showing so give the bottom
-          // area back to the source view
+          // We have no variables window showing so give the bottom area
+          // back to the source view
           source_window_sp->Resize(source_bounds.size.width,
                                    source_bounds.size.height +
                                        registers_window_sp->GetHeight());
@@ -3732,16 +3726,17 @@
       } else {
         Rect new_regs_rect;
         if (variables_window_sp) {
-          // We have a variables window, split it into two columns
-          // where the left hand side will be the variables and the
-          // right hand side will be the registers
+          // We have a variables window, split it into two columns where
+          // the left hand side will be the variables and the right hand
+          // side will be the registers
           const Rect variables_bounds = variables_window_sp->GetBounds();
           Rect new_vars_rect;
           variables_bounds.VerticalSplitPercentage(0.50, new_vars_rect,
                                                    new_regs_rect);
           variables_window_sp->SetBounds(new_vars_rect);
         } else {
-          // No registers window, grab the bottom part of the source window
+          // No registers window, grab the bottom part of the source
+          // window
           Rect new_source_rect;
           source_bounds.HorizontalSplitPercentage(0.70, new_source_rect,
                                                   new_regs_rect);
@@ -3946,8 +3941,8 @@
             m_selected_line = m_pc_line;
 
           if (m_file_sp && m_file_sp->FileSpecMatches(m_sc.line_entry.file)) {
-            // Same file, nothing to do, we should either have the
-            // lines or not (source file missing)
+            // Same file, nothing to do, we should either have the lines
+            // or not (source file missing)
             if (m_selected_line >= static_cast<size_t>(m_first_visible_line)) {
               if (m_selected_line >= m_first_visible_line + num_visible_lines)
                 m_first_visible_line = m_selected_line - 10;
@@ -4071,8 +4066,8 @@
           window.MoveCursor(1, line_y);
           const bool is_pc_line = curr_line == m_pc_line;
           const bool line_is_selected = m_selected_line == curr_line;
-          // Highlight the line as the PC line first, then if the selected line
-          // isn't the same as the PC line, highlight it differently
+          // Highlight the line as the PC line first, then if the selected
+          // line isn't the same as the PC line, highlight it differently
           attr_t highlight_attr = 0;
           attr_t bp_attr = 0;
           if (is_pc_line)
@@ -4116,8 +4111,8 @@
                 size_t stop_description_len = strlen(stop_description);
                 int desc_x = window_width - stop_description_len - 16;
                 window.Printf("%*s", desc_x - window.GetCursorX(), "");
-                // window.MoveCursor(window_width - stop_description_len - 15,
-                // line_y);
+                // window.MoveCursor(window_width - stop_description_len -
+                // 15, line_y);
                 window.Printf("<<< Thread %u: %s ", thread->GetIndexID(),
                               stop_description);
               }
@@ -4196,8 +4191,8 @@
           window.MoveCursor(1, line_y);
           const bool is_pc_line = frame_sp && inst_idx == pc_idx;
           const bool line_is_selected = m_selected_line == inst_idx;
-          // Highlight the line as the PC line first, then if the selected line
-          // isn't the same as the PC line, highlight it differently
+          // Highlight the line as the PC line first, then if the selected
+          // line isn't the same as the PC line, highlight it differently
           attr_t highlight_attr = 0;
           attr_t bp_attr = 0;
           if (is_pc_line)
@@ -4263,8 +4258,8 @@
                 size_t stop_description_len = strlen(stop_description);
                 int desc_x = window_width - stop_description_len - 16;
                 window.Printf("%*s", desc_x - window.GetCursorX(), "");
-                // window.MoveCursor(window_width - stop_description_len - 15,
-                // line_y);
+                // window.MoveCursor(window_width - stop_description_len -
+                // 15, line_y);
                 window.Printf("<<< Thread %u: %s ", thread->GetIndexID(),
                               stop_description);
               }
@@ -4656,7 +4651,8 @@
     status_window_sp->SetDelegate(
         WindowDelegateSP(new StatusBarWindowDelegate(m_debugger)));
 
-    // Show the main help window once the first time the curses GUI is launched
+    // Show the main help window once the first time the curses GUI is
+    // launched
     static bool g_showed_help = false;
     if (!g_showed_help) {
       g_showed_help = true;
Index: source/Core/Listener.cpp
===================================================================
--- source/Core/Listener.cpp
+++ source/Core/Listener.cpp
@@ -270,9 +270,8 @@
     uint32_t num_broadcaster_names, uint32_t event_type_mask, EventSP &event_sp,
     bool remove) {
   // NOTE: callers of this function must lock m_events_mutex using a
-  // Mutex::Locker
-  // and pass the locker as the first argument. m_events_mutex is no longer
-  // recursive.
+  // Mutex::Locker and pass the locker as the first argument.
+  // m_events_mutex is no longer recursive.
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
 
   if (m_events.empty())
@@ -304,11 +303,10 @@
 
     if (remove) {
       m_events.erase(pos);
-      // Unlock the event queue here.  We've removed this event and are about to
-      // return
-      // it so it should be okay to get the next event off the queue here - and
-      // it might
-      // be useful to do that in the "DoOnRemoval".
+      // Unlock the event queue here.  We've removed this event and are
+      // about to return it so it should be okay to get the next event off
+      // the queue here - and it might be useful to do that in the
+      // "DoOnRemoval".
       lock.unlock();
       event_sp->DoOnRemoval();
     }
@@ -434,8 +432,9 @@
   if (!manager_sp)
     return 0;
 
-  // The BroadcasterManager mutex must be locked before m_broadcasters_mutex
-  // to avoid violating the lock hierarchy (manager before broadcasters).
+  // The BroadcasterManager mutex must be locked before
+  // m_broadcasters_mutex to avoid violating the lock hierarchy (manager
+  // before broadcasters).
   std::lock_guard<std::recursive_mutex> manager_guard(
       manager_sp->m_manager_mutex);
   std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
Index: source/Core/Mangled.cpp
===================================================================
--- source/Core/Mangled.cpp
+++ source/Core/Mangled.cpp
@@ -17,8 +17,8 @@
 #endif
 
 #ifdef LLDB_USE_BUILTIN_DEMANGLER
-// Provide a fast-path demangler implemented in FastDemangle.cpp until it can
-// replace the existing C++ demangler with a complete implementation
+// Provide a fast-path demangler implemented in FastDemangle.cpp until it
+// can replace the existing C++ demangler with a complete implementation
 #include "lldb/Utility/FastDemangle.h"
 #include "llvm/Demangle/Demangle.h"
 #else
@@ -85,15 +85,14 @@
 static const ConstString &
 get_demangled_name_without_arguments(ConstString mangled,
                                      ConstString demangled) {
-  // This pair is <mangled name, demangled name without function arguments>
+  // This pair is <mangled name, demangled name without function
+  // arguments>
   static std::pair<ConstString, ConstString>
       g_most_recent_mangled_to_name_sans_args;
 
-  // Need to have the mangled & demangled names we're currently examining as
-  // statics
-  // so we can return a const ref to them at the end of the func if we don't
-  // have
-  // anything better.
+  // Need to have the mangled & demangled names we're currently examining
+  // as statics so we can return a const ref to them at the end of the
+  // func if we don't have anything better.
   static ConstString g_last_mangled;
   static ConstString g_last_demangled;
 
@@ -184,8 +183,8 @@
 }
 
 //----------------------------------------------------------------------
-// Logical NOT operator. This allows code to check any Mangled
-// objects to see if they are invalid using code such as:
+// Logical NOT operator. This allows code to check any Mangled objects to
+// see if they are invalid using code such as:
 //
 //  Mangled mangled(...);
 //  if (!file_spec)
@@ -211,9 +210,9 @@
 }
 
 //----------------------------------------------------------------------
-// Set the string value in this objects. If "mangled" is true, then
-// the mangled named is set with the new value in "s", else the
-// demangled name is set.
+// Set the string value in this objects. If "mangled" is true, then the
+// mangled named is set with the new value in "s", else the demangled name
+// is set.
 //----------------------------------------------------------------------
 void Mangled::SetValue(const ConstString &s, bool mangled) {
   if (s) {
@@ -246,16 +245,16 @@
 }
 
 //----------------------------------------------------------------------
-// Generate the demangled name on demand using this accessor. Code in
-// this class will need to use this accessor if it wishes to decode
-// the demangled name. The result is cached and will be kept until a
-// new string value is supplied to this object, or until the end of the
+// Generate the demangled name on demand using this accessor. Code in this
+// class will need to use this accessor if it wishes to decode the
+// demangled name. The result is cached and will be kept until a new
+// string value is supplied to this object, or until the end of the
 // object's lifetime.
 //----------------------------------------------------------------------
 const ConstString &
 Mangled::GetDemangledName(lldb::LanguageType language) const {
-  // Check to make sure we have a valid mangled name and that we
-  // haven't already decoded our mangled name.
+  // Check to make sure we have a valid mangled name and that we haven't
+  // already decoded our mangled name.
   if (m_mangled && !m_demangled) {
     // We need to generate and cache the demangled name.
     static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
@@ -269,8 +268,8 @@
     ManglingScheme mangling_scheme{cstring_mangling_scheme(mangled_name)};
     if (mangling_scheme != eManglingSchemeNone &&
         !m_mangled.GetMangledCounterpart(m_demangled)) {
-      // We didn't already mangle this name, demangle it and if all goes well
-      // add it to our map.
+      // We didn't already mangle this name, demangle it and if all goes
+      // well add it to our map.
       char *demangled_name = nullptr;
       switch (mangling_scheme) {
       case eManglingSchemeMSVC: {
@@ -302,9 +301,8 @@
 #ifdef LLDB_USE_BUILTIN_DEMANGLER
         if (log)
           log->Printf("demangle itanium: %s", mangled_name);
-        // Try to use the fast-path demangler first for the
-        // performance win, falling back to the full demangler only
-        // when necessary
+        // Try to use the fast-path demangler first for the performance
+        // win, falling back to the full demangler only when necessary
         demangled_name = FastDemangle(mangled_name, m_mangled.GetLength());
         if (!demangled_name)
           demangled_name =
@@ -331,8 +329,8 @@
       }
     }
     if (!m_demangled) {
-      // Set the demangled string to the empty string to indicate we
-      // tried to parse it once and failed.
+      // Set the demangled string to the empty string to indicate we tried
+      // to parse it once and failed.
       m_demangled.SetCString("");
     }
   }
@@ -370,8 +368,8 @@
     return get_demangled_name_without_arguments(m_mangled, demangled);
   }
   if (preference == ePreferDemangled) {
-    // Call the accessor to make sure we get a demangled name in case
-    // it hasn't been demangled yet...
+    // Call the accessor to make sure we get a demangled name in case it
+    // hasn't been demangled yet...
     if (demangled)
       return demangled;
     return m_mangled;
@@ -380,8 +378,8 @@
 }
 
 //----------------------------------------------------------------------
-// Dump a Mangled object to stream "s". We don't force our
-// demangled name to be computed currently (we don't use the accessor).
+// Dump a Mangled object to stream "s". We don't force our demangled name
+// to be computed currently (we don't use the accessor).
 //----------------------------------------------------------------------
 void Mangled::Dump(Stream *s) const {
   if (m_mangled) {
@@ -407,8 +405,8 @@
 
 //----------------------------------------------------------------------
 // Return the size in byte that this object takes in memory. The size
-// includes the size of the objects it owns, and not the strings that
-// it references because they are shared strings.
+// includes the size of the objects it owns, and not the strings that it
+// references because they are shared strings.
 //----------------------------------------------------------------------
 size_t Mangled::MemorySize() const {
   return m_mangled.MemorySize() + m_demangled.MemorySize();
@@ -433,8 +431,8 @@
         return lldb::eLanguageTypeObjC;
     }
   } else {
-    // ObjC names aren't really mangled, so they won't necessarily be in the 
-    // mangled name slot.
+    // ObjC names aren't really mangled, so they won't necessarily be in
+    // the  mangled name slot.
     ConstString demangled_name = GetDemangledName(lldb::eLanguageTypeUnknown);
     if (demangled_name 
         && ObjCLanguage::IsPossibleObjCMethodName(demangled_name.GetCString()))
Index: source/Core/Module.cpp
===================================================================
--- source/Core/Module.cpp
+++ source/Core/Module.cpp
@@ -79,21 +79,18 @@
 using namespace lldb;
 using namespace lldb_private;
 
-// Shared pointers to modules track module lifetimes in
-// targets and in the global module, but this collection
-// will track all module objects that are still alive
+// Shared pointers to modules track module lifetimes in targets and in the
+// global module, but this collection will track all module objects that
+// are still alive
 typedef std::vector<Module *> ModuleCollection;
 
 static ModuleCollection &GetModuleCollection() {
-  // This module collection needs to live past any module, so we could either
-  // make it a
-  // shared pointer in each module or just leak is.  Since it is only an empty
-  // vector by
-  // the time all the modules have gone away, we just leak it for now.  If we
-  // decide this
-  // is a big problem we can introduce a Finalize method that will tear
-  // everything down in
-  // a predictable order.
+  // This module collection needs to live past any module, so we could
+  // either make it a shared pointer in each module or just leak is.
+  // Since it is only an empty vector by the time all the modules have
+  // gone away, we just leak it for now.  If we decide this is a big
+  // problem we can introduce a Finalize method that will tear everything
+  // down in a predictable order.
 
   static ModuleCollection *g_module_collection = nullptr;
   if (g_module_collection == nullptr)
@@ -105,8 +102,8 @@
 std::recursive_mutex &Module::GetAllocationModuleCollectionMutex() {
   // NOTE: The mutex below must be leaked since the global module list in
   // the ModuleList class will get torn at some point, and we can't know
-  // if it will tear itself down before the "g_module_collection_mutex" below
-  // will. So we leak a Mutex object below to safeguard against that
+  // if it will tear itself down before the "g_module_collection_mutex"
+  // below will. So we leak a Mutex object below to safeguard against that
 
   static std::recursive_mutex *g_module_collection_mutex = nullptr;
   if (g_module_collection_mutex == nullptr)
@@ -152,20 +149,19 @@
                 module_spec.GetObjectName().IsEmpty() ? "" : ")");
 
   // First extract all module specifications from the file using the local
-  // file path. If there are no specifications, then don't fill anything in
+  // file path. If there are no specifications, then don't fill anything
+  // in
   ModuleSpecList modules_specs;
   if (ObjectFile::GetModuleSpecifications(module_spec.GetFileSpec(), 0, 0,
                                           modules_specs) == 0)
     return;
 
-  // Now make sure that one of the module specifications matches what we just
-  // extract. We might have a module specification that specifies a file
-  // "/usr/lib/dyld"
-  // with UUID XXX, but we might have a local version of "/usr/lib/dyld" that
-  // has
-  // UUID YYY and we don't want those to match. If they don't match, just don't
-  // fill any ivars in so we don't accidentally grab the wrong file later since
-  // they don't match...
+  // Now make sure that one of the module specifications matches what we
+  // just extract. We might have a module specification that specifies a
+  // file "/usr/lib/dyld" with UUID XXX, but we might have a local version
+  // of "/usr/lib/dyld" that has UUID YYY and we don't want those to
+  // match. If they don't match, just don't fill any ivars in so we don't
+  // accidentally grab the wrong file later since they don't match...
   ModuleSpec matching_module_spec;
   if (modules_specs.FindMatchingModuleSpec(module_spec, matching_module_spec) ==
       0)
@@ -177,15 +173,15 @@
     m_mod_time =
         FileSystem::GetModificationTime(matching_module_spec.GetFileSpec());
 
-  // Copy the architecture from the actual spec if we got one back, else use the
-  // one that was specified
+  // Copy the architecture from the actual spec if we got one back, else
+  // use the one that was specified
   if (matching_module_spec.GetArchitecture().IsValid())
     m_arch = matching_module_spec.GetArchitecture();
   else if (module_spec.GetArchitecture().IsValid())
     m_arch = module_spec.GetArchitecture();
 
-  // Copy the file spec over and use the specified one (if there was one) so we
-  // don't use a path that might have gotten resolved a path in
+  // Copy the file spec over and use the specified one (if there was one)
+  // so we don't use a path that might have gotten resolved a path in
   // 'matching_module_spec'
   if (module_spec.GetFileSpec())
     m_file = module_spec.GetFileSpec();
@@ -253,8 +249,8 @@
 }
 
 Module::~Module() {
-  // Lock our module down while we tear everything down to make sure
-  // we don't get any access to the module while it is being destroyed
+  // Lock our module down while we tear everything down to make sure we
+  // don't get any access to the module while it is being destroyed
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   // Scope for locker below...
   {
@@ -276,9 +272,9 @@
                 m_object_name.IsEmpty() ? "" : ")");
   // Release any auto pointers before we start tearing down our member
   // variables since the object file and symbol files might need to make
-  // function calls back into this module object. The ordering is important
-  // here because symbol files can require the module object file. So we tear
-  // down the symbol file first, then the object file.
+  // function calls back into this module object. The ordering is
+  // important here because symbol files can require the module object
+  // file. So we tear down the symbol file first, then the object file.
   m_sections_ap.reset();
   m_symfile_ap.reset();
   m_objfile_sp.reset();
@@ -307,10 +303,9 @@
           s.Printf("0x%16.16" PRIx64, header_addr);
           m_object_name.SetString(s.GetString());
 
-          // Once we get the object file, update our module with the object
-          // file's
-          // architecture since it might differ in vendor/os if some parts were
-          // unknown.
+          // Once we get the object file, update our module with the
+          // object file's architecture since it might differ in vendor/os
+          // if some parts were unknown.
           m_objfile_sp->GetArchitecture(m_arch);
         } else {
           error.SetErrorString("unable to find suitable object file plug-in");
@@ -432,17 +427,18 @@
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   uint32_t resolved_flags = 0;
 
-  // Clear the result symbol context in case we don't find anything, but don't
-  // clear the target
+  // Clear the result symbol context in case we don't find anything, but
+  // don't clear the target
   sc.Clear(false);
 
   // Get the section from the section/offset address.
   SectionSP section_sp(so_addr.GetSection());
 
-  // Make sure the section matches this module before we try and match anything
+  // Make sure the section matches this module before we try and match
+  // anything
   if (section_sp && section_sp->GetModule().get() == this) {
-    // If the section offset based address resolved itself, then this
-    // is the right module.
+    // If the section offset based address resolved itself, then this is
+    // the right module.
     sc.module_sp = shared_from_this();
     resolved_flags |= eSymbolContextModule;
 
@@ -450,8 +446,8 @@
     if (!sym_vendor)
       return resolved_flags;
 
-    // Resolve the compile unit, function, block, line table or line
-    // entry if requested.
+    // Resolve the compile unit, function, block, line table or line entry
+    // if requested.
     if (resolve_scope & eSymbolContextCompUnit ||
         resolve_scope & eSymbolContextFunction ||
         resolve_scope & eSymbolContextBlock ||
@@ -461,8 +457,8 @@
           sym_vendor->ResolveSymbolContext(so_addr, resolve_scope, sc);
     }
 
-    // Resolve the symbol if requested, but don't re-look it up if we've already
-    // found it.
+    // Resolve the symbol if requested, but don't re-look it up if we've
+    // already found it.
     if (resolve_scope & eSymbolContextSymbol &&
         !(resolved_flags & eSymbolContextSymbol)) {
       Symtab *symtab = sym_vendor->GetSymtab();
@@ -494,9 +490,9 @@
             // We have a synthetic symbol so lets check if the object file
             // from the symbol file in the symbol vendor is different than
             // the object file for the module, and if so search its symbol
-            // table to see if we can come up with a better symbol. For example
-            // dSYM files on MacOSX have an unstripped symbol table inside of
-            // them.
+            // table to see if we can come up with a better symbol. For
+            // example dSYM files on MacOSX have an unstripped symbol
+            // table inside of them.
             ObjectFile *symtab_objfile = symtab->GetObjectFile();
             if (symtab_objfile && symtab_objfile->IsStripped()) {
               SymbolFile *symfile = sym_vendor->GetSymbolFile();
@@ -521,11 +517,10 @@
       }
     }
 
-    // For function symbols, so_addr may be off by one.  This is a convention
-    // consistent
-    // with FDE row indices in eh_frame sections, but requires extra logic here
-    // to permit
-    // symbol lookup for disassembly and unwind.
+    // For function symbols, so_addr may be off by one.  This is a
+    // convention consistent with FDE row indices in eh_frame sections,
+    // but requires extra logic here to permit symbol lookup for
+    // disassembly and unwind.
     if (resolve_scope & eSymbolContextSymbol &&
         !(resolved_flags & eSymbolContextSymbol) && resolve_tail_call_address &&
         so_addr.IsSectionOffset()) {
@@ -542,9 +537,8 @@
           if (addr_range.GetBaseAddress().GetSection() ==
               so_addr.GetSection()) {
             // If the requested address is one past the address range of a
-            // function (i.e. a tail call),
-            // or the decremented address is the start of a function (i.e. some
-            // forms of trampoline),
+            // function (i.e. a tail call), or the decremented address is
+            // the start of a function (i.e. some forms of trampoline),
             // indicate that the symbol has been resolved.
             if (so_addr.GetOffset() ==
                     addr_range.GetBaseAddress().GetOffset() ||
@@ -676,26 +670,24 @@
     m_name_type_mask = name_type_mask;
     if (name_type_mask & eFunctionNameTypeMethod ||
         name_type_mask & eFunctionNameTypeBase) {
-      // If they've asked for a CPP method or function name and it can't be
-      // that, we don't
-      // even need to search for CPP methods or names.
+      // If they've asked for a CPP method or function name and it can't
+      // be that, we don't even need to search for CPP methods or names.
       CPlusPlusLanguage::MethodName cpp_method(name);
       if (cpp_method.IsValid()) {
         basename = cpp_method.GetBasename();
 
         if (!cpp_method.GetQualifiers().empty()) {
-          // There is a "const" or other qualifier following the end of the
-          // function parens,
-          // this can't be a eFunctionNameTypeBase
+          // There is a "const" or other qualifier following the end of
+          // the function parens, this can't be a eFunctionNameTypeBase
           m_name_type_mask &= ~(eFunctionNameTypeBase);
           if (m_name_type_mask == eFunctionNameTypeNone)
             return;
         }
       } else {
-        // If the CPP method parser didn't manage to chop this up, try to fill
-        // in the base name if we can.
-        // If a::b::c is passed in, we need to just look up "c", and then we'll
-        // filter the result later.
+        // If the CPP method parser didn't manage to chop this up, try to
+        // fill in the base name if we can. If a::b::c is passed in, we
+        // need to just look up "c", and then we'll filter the result
+        // later.
         CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context,
                                                        basename);
       }
@@ -709,8 +701,8 @@
       }
     }
 
-    // Still try and get a basename in case someone specifies a name type mask
-    // of eFunctionNameTypeFull and a name like "A::func"
+    // Still try and get a basename in case someone specifies a name type
+    // mask of eFunctionNameTypeFull and a name like "A::func"
     if (basename.empty()) {
       if (name_type_mask & eFunctionNameTypeFull &&
           !CPlusPlusLanguage::IsCPPMangledName(name_cstr)) {
@@ -724,19 +716,16 @@
   }
 
   if (!basename.empty()) {
-    // The name supplied was a partial C++ path like "a::count". In this case we
-    // want to do a
-    // lookup on the basename "count" and then make sure any matching results
-    // contain "a::count"
-    // so that it would match "b::a::count" and "a::count". This is why we set
-    // "match_name_after_lookup"
-    // to true
+    // The name supplied was a partial C++ path like "a::count". In this
+    // case we want to do a lookup on the basename "count" and then make
+    // sure any matching results contain "a::count" so that it would match
+    // "b::a::count" and "a::count". This is why we set
+    // "match_name_after_lookup" to true
     m_lookup_name.SetString(basename);
     m_match_name_after_lookup = true;
   } else {
-    // The name is already correct, just use the exact name as supplied, and we
-    // won't need
-    // to check if any matches contain "name"
+    // The name is already correct, just use the exact name as supplied,
+    // and we won't need to check if any matches contain "name"
     m_lookup_name = name;
     m_match_name_after_lookup = false;
   }
@@ -760,18 +749,18 @@
     }
   }
 
-  // If we have only full name matches we might have tried to set breakpoint on
-  // "func" and specified eFunctionNameTypeFull, but we might have found
-  // "a::func()", "a::b::func()", "c::func()", "func()" and "func". Only
-  // "func()" and "func" should end up matching.
+  // If we have only full name matches we might have tried to set
+  // breakpoint on "func" and specified eFunctionNameTypeFull, but we
+  // might have found "a::func()", "a::b::func()", "c::func()", "func()"
+  // and "func". Only "func()" and "func" should end up matching.
   if (m_name_type_mask == eFunctionNameTypeFull) {
     SymbolContext sc;
     size_t i = start_idx;
     while (i < sc_list.GetSize()) {
       if (!sc_list.GetContextAtIndex(i, sc))
         break;
-      // Make sure the mangled and demangled names don't match before we try
-      // to pull anything out
+      // Make sure the mangled and demangled names don't match before we
+      // try to pull anything out
       ConstString mangled_name(sc.GetFunctionName(Mangled::ePreferMangled));
       ConstString full_name(sc.GetFunctionName());
       if (mangled_name != m_name && full_name != m_name)
@@ -812,7 +801,8 @@
 
   const size_t old_size = sc_list.GetSize();
 
-  // Find all the functions (not symbols, but debug information functions...
+  // Find all the functions (not symbols, but debug information
+  // functions...
   SymbolVendor *symbols = GetSymbolVendor();
 
   if (name_type_mask & eFunctionNameTypeAuto) {
@@ -867,7 +857,8 @@
   if (symbols) {
     symbols->FindFunctions(regex, include_inlines, append, sc_list);
 
-    // Now check our symbol table for symbols that are code symbols if requested
+    // Now check our symbol table for symbols that are code symbols if
+    // requested
     if (include_symbols) {
       Symtab *symtab = symbols->GetSymtab();
       if (symtab) {
@@ -882,7 +873,8 @@
           size_t num_functions_added_to_sc_list =
               end_functions_added_index - start_size;
           if (num_functions_added_to_sc_list == 0) {
-            // No functions were added, just symbols, so we can just append them
+            // No functions were added, just symbols, so we can just
+            // append them
             for (size_t i = 0; i < num_matches; ++i) {
               sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
               SymbolType sym_type = sc.symbol->GetType();
@@ -1003,10 +995,10 @@
   TypeMap typesmap;
   if (Type::GetTypeScopeAndBasename(type_name_cstr, type_scope, type_basename,
                                     type_class)) {
-    // Check if "name" starts with "::" which means the qualified type starts
-    // from the root namespace and implies and exact match. The typenames we
-    // get back from clang do not start with "::" so we need to strip this off
-    // in order to get the qualified names to match
+    // Check if "name" starts with "::" which means the qualified type
+    // starts from the root namespace and implies and exact match. The
+    // typenames we get back from clang do not start with "::" so we need
+    // to strip this off in order to get the qualified names to match
     exact_match = type_scope.consume_front("::");
 
     ConstString type_basename_const_str(type_basename);
@@ -1020,9 +1012,9 @@
     // The type is not in a namespace/class scope, just search for it by
     // basename
     if (type_class != eTypeClassAny) {
-      // The "type_name_cstr" will have been modified if we have a valid type
-      // class
-      // prefix (like "struct", "class", "union", "typedef" etc).
+      // The "type_name_cstr" will have been modified if we have a valid
+      // type class prefix (like "struct", "class", "union", "typedef"
+      // etc).
       FindTypes_Impl(sc, ConstString(type_basename), nullptr, append,
                      max_matches, searched_symbol_files, typesmap);
       typesmap.RemoveMismatchedTypes(type_class);
@@ -1257,13 +1249,12 @@
             shared_from_this(), &m_file, m_object_offset,
             file_size - m_object_offset, data_sp, data_offset);
         if (m_objfile_sp) {
-          // Once we get the object file, update our module with the object
-          // file's
-          // architecture since it might differ in vendor/os if some parts were
-          // unknown.  But since the matching arch might already be more
-          // specific
-          // than the generic COFF architecture, only merge in those values that
-          // overwrite unspecified unknown values.
+          // Once we get the object file, update our module with the
+          // object file's architecture since it might differ in vendor/os
+          // if some parts were unknown.  But since the matching arch
+          // might already be more specific than the generic COFF
+          // architecture, only merge in those values that overwrite
+          // unspecified unknown values.
           ArchSpec new_arch;
           m_objfile_sp->GetArchitecture(new_arch);
           m_arch.MergeFrom(new_arch);
@@ -1406,7 +1397,8 @@
   if (!sym_vendor) {
     return;
   }
-  // Prime the symbol file first, since it adds symbols to the symbol table.
+  // Prime the symbol file first, since it adds symbols to the symbol
+  // table.
   if (SymbolFile *symbol_file = sym_vendor->GetSymbolFile()) {
     symbol_file->PreloadSymbols();
   }
@@ -1426,35 +1418,33 @@
     SymbolFile *symbol_file = m_symfile_ap->GetSymbolFile();
     if (section_list && symbol_file) {
       ObjectFile *obj_file = symbol_file->GetObjectFile();
-      // Make sure we have an object file and that the symbol vendor's objfile
-      // isn't
-      // the same as the module's objfile before we remove any sections for
-      // it...
+      // Make sure we have an object file and that the symbol vendor's
+      // objfile isn't the same as the module's objfile before we remove
+      // any sections for it...
       if (obj_file) {
-        // Check to make sure we aren't trying to specify the file we already
-        // have
+        // Check to make sure we aren't trying to specify the file we
+        // already have
         if (obj_file->GetFileSpec() == file) {
-          // We are being told to add the exact same file that we already have
-          // we don't have to do anything.
+          // We are being told to add the exact same file that we already
+          // have we don't have to do anything.
           return;
         }
 
-        // Cleare the current symtab as we are going to replace it with a new
-        // one
+        // Cleare the current symtab as we are going to replace it with a
+        // new one
         obj_file->ClearSymtab();
 
         // The symbol file might be a directory bundle ("/tmp/a.out.dSYM")
-        // instead
-        // of a full path to the symbol file within the bundle
-        // ("/tmp/a.out.dSYM/Contents/Resources/DWARF/a.out"). So we need to
-        // check this
+        // instead of a full path to the symbol file within the bundle
+        // ("/tmp/a.out.dSYM/Contents/Resources/DWARF/a.out"). So we need
+        // to check this
 
         if (llvm::sys::fs::is_directory(file.GetPath())) {
           std::string new_path(file.GetPath());
           std::string old_path(obj_file->GetFileSpec().GetPath());
           if (old_path.find(new_path) == 0) {
-            // We specified the same bundle as the symbol file that we already
-            // have
+            // We specified the same bundle as the symbol file that we
+            // already have
             return;
           }
         }
@@ -1471,9 +1461,9 @@
         }
       }
     }
-    // Keep all old symbol files around in case there are any lingering type
-    // references in
-    // any SBValue objects that might have been handed out.
+    // Keep all old symbol files around in case there are any lingering
+    // type references in any SBValue objects that might have been handed
+    // out.
     m_old_symfiles.push_back(std::move(m_symfile_ap));
   }
   m_symfile_spec = file;
@@ -1658,17 +1648,17 @@
 ModuleSP
 Module::CreateJITModule(const lldb::ObjectFileJITDelegateSP &delegate_sp) {
   if (delegate_sp) {
-    // Must create a module and place it into a shared pointer before
-    // we can create an object file since it has a std::weak_ptr back
-    // to the module, so we need to control the creation carefully in
-    // this static function
+    // Must create a module and place it into a shared pointer before we
+    // can create an object file since it has a std::weak_ptr back to the
+    // module, so we need to control the creation carefully in this static
+    // function
     ModuleSP module_sp(new Module());
     module_sp->m_objfile_sp =
         std::make_shared<ObjectFileJIT>(module_sp, delegate_sp);
     if (module_sp->m_objfile_sp) {
-      // Once we get the object file, update our module with the object file's
-      // architecture since it might differ in vendor/os if some parts were
-      // unknown.
+      // Once we get the object file, update our module with the object
+      // file's architecture since it might differ in vendor/os if some
+      // parts were unknown.
       module_sp->m_objfile_sp->GetArchitecture(module_sp->m_arch);
     }
     return module_sp;
Index: source/Core/ModuleList.cpp
===================================================================
--- source/Core/ModuleList.cpp
+++ source/Core/ModuleList.cpp
@@ -132,8 +132,8 @@
     //  in thread A: | in thread B:
     //    x = y;     |   y = x;
     //
-    // This establishes correct(same) lock taking order and thus
-    // avoids priority inversion.
+    // This establishes correct(same) lock taking order and thus avoids
+    // priority inversion.
     if (uintptr_t(this) > uintptr_t(&rhs)) {
       std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
       std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
@@ -562,9 +562,10 @@
   if (total_matches < max_matches) {
     SymbolContext world_sc;
     for (pos = m_modules.begin(); pos != end; ++pos) {
-      // Search the module if the module is not equal to the one in the symbol
-      // context "sc". If "sc" contains a empty module shared pointer, then
-      // the comparison will always be true (valid_module_ptr != nullptr).
+      // Search the module if the module is not equal to the one in the
+      // symbol context "sc". If "sc" contains a empty module shared
+      // pointer, then the comparison will always be true
+      // (valid_module_ptr != nullptr).
       if (sc.module_sp.get() != (*pos).get())
         total_matches +=
             (*pos)->FindTypes(world_sc, name, name_is_fully_qualified,
@@ -733,9 +734,9 @@
   static SharedModuleListInfo *g_shared_module_list_info = nullptr;
   static llvm::once_flag g_once_flag;
   llvm::call_once(g_once_flag, []() {
-    // NOTE: Intentionally leak the module list so a program doesn't have to
-    // cleanup all modules and object files as it exits. This just wastes time
-    // doing a bunch of cleanup that isn't required.
+    // NOTE: Intentionally leak the module list so a program doesn't have
+    // to cleanup all modules and object files as it exits. This just
+    // wastes time doing a bunch of cleanup that isn't required.
     if (g_shared_module_list_info == nullptr)
       g_shared_module_list_info = new SharedModuleListInfo();
   });
@@ -815,8 +816,8 @@
           shared_module_list.Remove(module_sp);
           module_sp.reset();
         } else {
-          // The module matches and the module was not modified from
-          // when it was last loaded.
+          // The module matches and the module was not modified from when
+          // it was last loaded.
           return error;
         }
       }
@@ -828,11 +829,12 @@
 
   module_sp.reset(new Module(module_spec));
   // Make sure there are a module and an object file since we can specify
-  // a valid file path with an architecture that might not be in that file.
-  // By getting the object file we can guarantee that the architecture matches
+  // a valid file path with an architecture that might not be in that
+  // file. By getting the object file we can guarantee that the
+  // architecture matches
   if (module_sp->GetObjectFile()) {
-    // If we get in here we got the correct arch, now we just need
-    // to verify the UUID if one was given
+    // If we get in here we got the correct arch, now we just need to
+    // verify the UUID if one was given
     if (uuid_ptr && *uuid_ptr != module_sp->GetUUID()) {
       module_sp.reset();
     } else {
@@ -871,8 +873,8 @@
       resolved_module_spec.GetFileSpec() = search_path_spec;
       module_sp.reset(new Module(resolved_module_spec));
       if (module_sp->GetObjectFile()) {
-        // If we get in here we got the correct arch, now we just need
-        // to verify the UUID if one was given
+        // If we get in here we got the correct arch, now we just need to
+        // verify the UUID if one was given
         if (uuid_ptr && *uuid_ptr != module_sp->GetUUID()) {
           module_sp.reset();
         } else {
@@ -893,9 +895,9 @@
     }
   }
 
-  // Either the file didn't exist where at the path, or no path was given, so
-  // we now have to use more extreme measures to try and find the appropriate
-  // module.
+  // Either the file didn't exist where at the path, or no path was given,
+  // so we now have to use more extreme measures to try and find the
+  // appropriate module.
 
   // Fixup the incoming path in case the path points to a valid file, yet
   // the arch or UUID (if one was passed in) don't match.
@@ -949,8 +951,9 @@
                                        matching_module_list) > 0) {
       module_sp = matching_module_list.GetModuleAtIndex(0);
 
-      // If we didn't have a UUID in mind when looking for the object file,
-      // then we should make sure the modification time hasn't changed!
+      // If we didn't have a UUID in mind when looking for the object
+      // file, then we should make sure the modification time hasn't
+      // changed!
       if (platform_module_spec.GetUUIDPtr() == nullptr) {
         auto file_spec_mod_time = FileSystem::GetModificationTime(
             located_binary_modulespec.GetFileSpec());
@@ -967,10 +970,10 @@
 
     if (!module_sp) {
       module_sp.reset(new Module(platform_module_spec));
-      // Make sure there are a module and an object file since we can specify
-      // a valid file path with an architecture that might not be in that file.
-      // By getting the object file we can guarantee that the architecture
-      // matches
+      // Make sure there are a module and an object file since we can
+      // specify a valid file path with an architecture that might not be
+      // in that file. By getting the object file we can guarantee that
+      // the architecture matches
       if (module_sp && module_sp->GetObjectFile()) {
         if (module_sp->GetObjectFile()->GetType() ==
             ObjectFile::eTypeStubLibrary) {
Index: source/Core/PluginManager.cpp
===================================================================
--- source/Core/PluginManager.cpp
+++ source/Core/PluginManager.cpp
@@ -97,9 +97,9 @@
 
   namespace fs = llvm::sys::fs;
   // If we have a regular file, a symbolic link or unknown file type, try
-  // and process the file. We must handle unknown as sometimes the directory
-  // enumeration might be enumerating a file system that doesn't have correct
-  // file type information.
+  // and process the file. We must handle unknown as sometimes the
+  // directory enumeration might be enumerating a file system that doesn't
+  // have correct file type information.
   if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
       ft == fs::file_type::type_unknown) {
     FileSpec plugin_file_spec(file_spec);
@@ -127,18 +127,15 @@
           plugin_info.plugin_term_callback = CastToFPtr<PluginTermCallback>(
               plugin_info.library.getAddressOfSymbol("LLDBPluginTerminate"));
         } else {
-          // The initialize function returned FALSE which means the plug-in
-          // might not be
-          // compatible, or might be too new or too old, or might not want to
-          // run on this
-          // machine.  Set it to a default-constructed instance to invalidate
-          // it.
+          // The initialize function returned FALSE which means the plug-
+          // in might not be compatible, or might be too new or too old,
+          // or might not want to run on this machine.  Set it to a
+          // default-constructed instance to invalidate it.
           plugin_info = PluginInfo();
         }
 
-        // Regardless of success or failure, cache the plug-in load
-        // in our plug-in info so we don't try to load it again and
-        // again.
+        // Regardless of success or failure, cache the plug-in load in our
+        // plug-in info so we don't try to load it again and again.
         SetPluginInfo(plugin_file_spec, plugin_info);
 
         return FileSpec::eEnumerateDirectoryResultNext;
@@ -148,10 +145,10 @@
 
   if (ft == fs::file_type::directory_file ||
       ft == fs::file_type::symlink_file || ft == fs::file_type::type_unknown) {
-    // Try and recurse into anything that a directory or symbolic link.
-    // We must also do this for unknown as sometimes the directory enumeration
-    // might be enumerating a file system that doesn't have correct file type
-    // information.
+    // Try and recurse into anything that a directory or symbolic link. We
+    // must also do this for unknown as sometimes the directory
+    // enumeration might be enumerating a file system that doesn't have
+    // correct file type information.
     return FileSpec::eEnumerateDirectoryResultEnter;
   }
 
@@ -187,8 +184,8 @@
 
   PluginTerminateMap::const_iterator pos, end = plugin_map.end();
   for (pos = plugin_map.begin(); pos != end; ++pos) {
-    // Call the plug-in "void LLDBPluginTerminate (void)" function if there
-    // is one (if the symbol was not nullptr).
+    // Call the plug-in "void LLDBPluginTerminate (void)" function if
+    // there is one (if the symbol was not nullptr).
     if (pos->second.library.isValid()) {
       if (pos->second.plugin_term_callback)
         pos->second.plugin_term_callback();
@@ -1528,7 +1525,8 @@
       return pos->create_callback(interpreter);
   }
 
-  // If we didn't find one, return the ScriptInterpreter for the null language.
+  // If we didn't find one, return the ScriptInterpreter for the null
+  // language.
   assert(none_instance != nullptr);
   return none_instance(interpreter);
 }
@@ -2360,8 +2358,8 @@
   }
 }
 
-// This is the preferred new way to register plugin specific settings.  e.g.
-// This will put a plugin's settings under e.g.
+// This is the preferred new way to register plugin specific settings.
+// e.g. This will put a plugin's settings under e.g.
 // "plugin.<plugin_type_name>.<plugin_type_desc>.SETTINGNAME".
 static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPlugins(
     Debugger &debugger, const ConstString &plugin_type_name,
@@ -2397,8 +2395,8 @@
 }
 
 // This is deprecated way to register plugin specific settings.  e.g.
-// "<plugin_type_name>.plugin.<plugin_type_desc>.SETTINGNAME"
-// and Platform generic settings would be under "platform.SETTINGNAME".
+// "<plugin_type_name>.plugin.<plugin_type_desc>.SETTINGNAME" and Platform
+// generic settings would be under "platform.SETTINGNAME".
 static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPluginsOldStyle(
     Debugger &debugger, const ConstString &plugin_type_name,
     const ConstString &plugin_type_desc, bool can_create) {
Index: source/Core/RegisterValue.cpp
===================================================================
--- source/Core/RegisterValue.cpp
+++ source/Core/RegisterValue.cpp
@@ -41,8 +41,8 @@
   DataExtractor data;
   if (GetData(data)) {
     bool name_printed = false;
-    // For simplicity, alignment of the register name printing applies only
-    // in the most common case where:
+    // For simplicity, alignment of the register name printing applies
+    // only in the most common case where:
     //
     //     prefix_with_name^prefix_with_alt_name is true
     //
@@ -69,8 +69,8 @@
         s->Printf(fmt.c_str(), reg_info->alt_name);
         name_printed = true;
       } else if (!name_printed) {
-        // No alternate name but we were asked to display a name, so show the
-        // main name
+        // No alternate name but we were asked to display a name, so show
+        // the main name
         s->Printf(fmt.c_str(), reg_info->name);
         name_printed = true;
       }
@@ -131,7 +131,8 @@
     return 0;
   }
 
-  // Prepare a memory buffer that contains some or all of the register value
+  // Prepare a memory buffer that contains some or all of the register
+  // value
   const uint32_t bytes_copied =
       reg_data.CopyByteOrderedData(0,               // src offset
                                    src_len,         // src length
@@ -185,8 +186,8 @@
     return 0;
   }
 
-  // Use a data extractor to correctly copy and pad the bytes read into the
-  // register value
+  // Use a data extractor to correctly copy and pad the bytes read into
+  // the register value
   DataExtractor src_data(src, src_len, src_byte_order, 4);
 
   error = SetValueFromData(reg_info, src_data, 0, true);
@@ -248,7 +249,8 @@
 void RegisterValue::Clear() { m_type = eTypeInvalid; }
 
 RegisterValue::Type RegisterValue::SetType(const RegisterInfo *reg_info) {
-  // To change the type, we simply copy the data in again, using the new format
+  // To change the type, we simply copy the data in again, using the new
+  // format
   RegisterValue copy;
   DataExtractor copy_data;
   if (copy.CopyValue(*this) && copy.GetData(copy_data))
@@ -280,8 +282,8 @@
     return error;
   }
 
-  // Cap the data length if there is more than enough bytes for this register
-  // value
+  // Cap the data length if there is more than enough bytes for this
+  // register value
   if (src_len > reg_info->byte_size)
     src_len = reg_info->byte_size;
 
@@ -357,8 +359,8 @@
                                 llvm::StringRef vector_str,
                                 const uint32_t byte_size,
                                 RegisterValue *reg_value) {
-  // Example: vector_str = "{0x2c 0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a
-  // 0x2a 0x3e 0x84 0x4f 0x2a 0x3e}".
+  // Example: vector_str = "{0x2c 0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac
+  // 0x4a 0x2a 0x3e 0x84 0x4f 0x2a 0x3e}".
   vector_str = vector_str.trim();
   vector_str.consume_front("{");
   vector_str.consume_back("}");
@@ -367,16 +369,16 @@
   char Sep = ' ';
 
   // The first split should give us:
-  // ('0x2c', '0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a 0x2a 0x3e 0x84 0x4f
-  // 0x2a 0x3e').
+  // ('0x2c', '0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a 0x2a 0x3e 0x84
+  // 0x4f 0x2a 0x3e').
   llvm::StringRef car;
   llvm::StringRef cdr = vector_str;
   std::tie(car, cdr) = vector_str.split(Sep);
   std::vector<uint8_t> bytes;
   unsigned byte = 0;
 
-  // Using radix auto-sensing by passing 0 as the radix.
-  // Keep on processing the vector elements as long as the parsing succeeds and
+  // Using radix auto-sensing by passing 0 as the radix. Keep on
+  // processing the vector elements as long as the parsing succeeds and
   // the vector size is < byte_size.
   while (!car.getAsInteger(0, byte) && bytes.size() < byte_size) {
     bytes.push_back(byte);
@@ -813,9 +815,9 @@
 void RegisterValue::SetBytes(const void *bytes, size_t length,
                              lldb::ByteOrder byte_order) {
   // If this assertion fires off we need to increase the size of
-  // buffer.bytes, or make it something that is allocated on
-  // the heap. Since the data buffer is in a union, we can't make it
-  // a collection class like SmallVector...
+  // buffer.bytes, or make it something that is allocated on the heap.
+  // Since the data buffer is in a union, we can't make it a collection
+  // class like SmallVector...
   if (bytes && length > 0) {
     assert(length <= sizeof(buffer.bytes) &&
            "Storing too many bytes in a RegisterValue.");
Index: source/Core/Scalar.cpp
===================================================================
--- source/Core/Scalar.cpp
+++ source/Core/Scalar.cpp
@@ -41,10 +41,10 @@
                                      // lhs/rhs will get promoted)
     ) {
   Scalar result;
-  // Initialize the promoted values for both the right and left hand side values
-  // to be the objects themselves. If no promotion is needed (both right and
-  // left
-  // have the same type), then the temp_value will not get used.
+  // Initialize the promoted values for both the right and left hand side
+  // values to be the objects themselves. If no promotion is needed (both
+  // right and left have the same type), then the temp_value will not get
+  // used.
   promoted_lhs_ptr = &lhs;
   promoted_rhs_ptr = &rhs;
   // Extract the types of both the right and left hand side values
@@ -69,7 +69,8 @@
   if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
     return promoted_lhs_ptr->GetType(); // Return the resulting max type
 
-  // Return the void type (zero) if we fail to promote either of the values.
+  // Return the void type (zero) if we fail to promote either of the
+  // values.
   return Scalar::e_void;
 }
 
@@ -129,13 +130,13 @@
     if (limit_byte_size < byte_size) {
       if (endian::InlHostByteOrder() == eByteOrderLittle) {
         // On little endian systems if we want fewer bytes from the
-        // current type we just specify fewer bytes since the LSByte
-        // is first...
+        // current type we just specify fewer bytes since the LSByte is
+        // first...
         byte_size = limit_byte_size;
       } else if (endian::InlHostByteOrder() == eByteOrderBig) {
-        // On big endian systems if we want fewer bytes from the
-        // current type have to advance our initial byte pointer and
-        // trim down the number of bytes since the MSByte is first
+        // On big endian systems if we want fewer bytes from the current
+        // type have to advance our initial byte pointer and trim down the
+        // number of bytes since the MSByte is first
         bytes += byte_size - limit_byte_size;
         byte_size = limit_byte_size;
       }
@@ -164,9 +165,8 @@
   case e_slonglong:
   case e_ulonglong:
     bytes = reinterpret_cast<const uint8_t *>(m_integer.getRawData());
-    // getRawData always returns a pointer to an uint64_t.  If we have a smaller
-    // type,
-    // we need to update the pointer on big-endian systems.
+    // getRawData always returns a pointer to an uint64_t.  If we have a
+    // smaller type, we need to update the pointer on big-endian systems.
     if (endian::InlHostByteOrder() == eByteOrderBig) {
       size_t byte_size = m_integer.getBitWidth() / 8;
       if (byte_size < 8)
@@ -176,9 +176,9 @@
   case e_sint128:
   case e_uint128:
     apint_words = m_integer.getRawData();
-    // getRawData always returns a pointer to an array of two uint64_t values,
-    // where the least-significant word always comes first.  On big-endian
-    // systems we need to swap the two words.
+    // getRawData always returns a pointer to an array of two uint64_t
+    // values, where the least-significant word always comes first.  On
+    // big-endian systems we need to swap the two words.
     if (endian::InlHostByteOrder() == eByteOrderBig) {
       swapped_words[0] = apint_words[1];
       swapped_words[1] = apint_words[0];
@@ -188,9 +188,9 @@
   case e_sint256:
   case e_uint256:
     apint_words = m_integer.getRawData();
-    // getRawData always returns a pointer to an array of four uint64_t values,
-    // where the least-significant word always comes first.  On big-endian
-    // systems we need to swap the four words.
+    // getRawData always returns a pointer to an array of four uint64_t
+    // values, where the least-significant word always comes first.  On
+    // big-endian systems we need to swap the four words.
     if (endian::InlHostByteOrder() == eByteOrderBig) {
       swapped_words[0] = apint_words[3];
       swapped_words[1] = apint_words[2];
@@ -208,9 +208,9 @@
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     apint_words = ldbl_val.getRawData();
-    // getRawData always returns a pointer to an array of two uint64_t values,
-    // where the least-significant word always comes first.  On big-endian
-    // systems we need to swap the two words.
+    // getRawData always returns a pointer to an array of two uint64_t
+    // values, where the least-significant word always comes first.  On
+    // big-endian systems we need to swap the two words.
     if (endian::InlHostByteOrder() == eByteOrderBig) {
       swapped_words[0] = apint_words[1];
       swapped_words[1] = apint_words[0];
@@ -2064,9 +2064,8 @@
       break;
     }
   }
-  // For division only, the only way it should make it here is if a promotion
-  // failed,
-  // or if we are trying to do a divide by zero.
+  // For division only, the only way it should make it here is if a
+  // promotion failed, or if we are trying to do a divide by zero.
   result.m_type = Scalar::e_void;
   return result;
 }
@@ -2563,7 +2562,8 @@
 
   const size_t src_len = data.GetByteSize();
 
-  // Prepare a memory buffer that contains some or all of the register value
+  // Prepare a memory buffer that contains some or all of the register
+  // value
   const size_t bytes_copied =
       data.CopyByteOrderedData(0,               // src offset
                                src_len,         // src length
Index: source/Core/SearchFilter.cpp
===================================================================
--- source/Core/SearchFilter.cpp
+++ source/Core/SearchFilter.cpp
@@ -261,8 +261,8 @@
 
       size_t n_modules = target_images.GetSize();
       for (size_t i = 0; i < n_modules; i++) {
-        // If this is the last level supplied, then call the callback directly,
-        // otherwise descend.
+        // If this is the last level supplied, then call the callback
+        // directly, otherwise descend.
         ModuleSP module_sp(target_images.GetModuleAtIndexUnlocked(i));
         if (!ModulePasses(module_sp))
           continue;
@@ -428,8 +428,8 @@
   }
 
   // If the module file spec is a full path, then we can just find the one
-  // filespec that passes.  Otherwise, we need to go through all modules and
-  // find the ones that match the file name.
+  // filespec that passes.  Otherwise, we need to go through all modules
+  // and find the ones that match the file name.
 
   const ModuleList &target_modules = m_target_sp->GetImages();
   std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
@@ -577,8 +577,8 @@
   }
 
   // If the module file spec is a full path, then we can just find the one
-  // filespec that passes.  Otherwise, we need to go through all modules and
-  // find the ones that match the file name.
+  // filespec that passes.  Otherwise, we need to go through all modules
+  // and find the ones that match the file name.
 
   const ModuleList &target_modules = m_target_sp->GetImages();
   std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
@@ -780,8 +780,8 @@
   }
 
   // If the module file spec is a full path, then we can just find the one
-  // filespec that passes.  Otherwise, we need to go through all modules and
-  // find the ones that match the file name.
+  // filespec that passes.  Otherwise, we need to go through all modules
+  // and find the ones that match the file name.
 
   ModuleList matching_modules;
   const ModuleList &target_images = m_target_sp->GetImages();
Index: source/Core/Section.cpp
===================================================================
--- source/Core/Section.cpp
+++ source/Core/Section.cpp
@@ -176,8 +176,8 @@
   SectionSP parent_sp(GetParent());
   if (parent_sp) {
     // This section has a parent which means m_file_addr is an offset into
-    // the parent section, so the file address for this section is the file
-    // address of the parent plus the offset
+    // the parent section, so the file address for this section is the
+    // file address of the parent plus the offset
     return parent_sp->GetFileAddress() + m_file_addr;
   }
   // This section has no parent, so m_file_addr is the file base address
@@ -239,8 +239,8 @@
   so_addr.SetSection(const_cast<Section *>(this)->shared_from_this());
 
 #ifdef LLDB_CONFIGURATION_DEBUG
-  // For debug builds, ensure that there are no orphaned (i.e., moduleless)
-  // sections.
+  // For debug builds, ensure that there are no orphaned (i.e.,
+  // moduleless) sections.
   assert(GetModule().get());
 #endif
   return true;
@@ -556,11 +556,9 @@
        sect_iter != end && sect_sp.get() == NULL; ++sect_iter) {
     Section *sect = sect_iter->get();
     if (sect->ContainsFileAddress(vm_addr)) {
-      // The file address is in this section. We need to make sure one of our
-      // child
-      // sections doesn't contain this address as well as obeying the depth
-      // limit
-      // that was passed in.
+      // The file address is in this section. We need to make sure one of
+      // our child sections doesn't contain this address as well as
+      // obeying the depth limit that was passed in.
       if (depth > 0)
         sect_sp = sect->GetChildren().FindSectionContainingFileAddress(
             vm_addr, depth - 1);
Index: source/Core/SourceManager.cpp
===================================================================
--- source/Core/SourceManager.cpp
+++ source/Core/SourceManager.cpp
@@ -79,8 +79,8 @@
 
   TargetSP target_sp(m_target_wp.lock());
 
-  // It the target source path map has been updated, get this file again so we
-  // can successfully remap the source file
+  // It the target source path map has been updated, get this file again
+  // so we can successfully remap the source file
   if (target_sp && file_sp &&
       file_sp->GetSourceMapModificationID() !=
           target_sp->GetSourcePathMap().GetModificationID())
@@ -104,32 +104,32 @@
 }
 
 static bool should_show_stop_column_with_ansi(DebuggerSP debugger_sp) {
-  // We don't use ANSI stop column formatting if we can't lookup values from
-  // the debugger.
+  // We don't use ANSI stop column formatting if we can't lookup values
+  // from the debugger.
   if (!debugger_sp)
     return false;
 
-  // We don't use ANSI stop column formatting if the debugger doesn't think
-  // it should be using color.
+  // We don't use ANSI stop column formatting if the debugger doesn't
+  // think it should be using color.
   if (!debugger_sp->GetUseColor())
     return false;
 
-  // We only use ANSI stop column formatting if we're either supposed to show
-  // ANSI where available (which we know we have when we get to this point), or
-  // if we're only supposed to use ANSI.
+  // We only use ANSI stop column formatting if we're either supposed to
+  // show ANSI where available (which we know we have when we get to this
+  // point), or if we're only supposed to use ANSI.
   const auto value = debugger_sp->GetStopShowColumn();
   return ((value == eStopShowColumnAnsiOrCaret) ||
           (value == eStopShowColumnAnsi));
 }
 
 static bool should_show_stop_column_with_caret(DebuggerSP debugger_sp) {
-  // We don't use text-based stop column formatting if we can't lookup values
-  // from the debugger.
+  // We don't use text-based stop column formatting if we can't lookup
+  // values from the debugger.
   if (!debugger_sp)
     return false;
 
-  // If we're asked to show the first available of ANSI or caret, then
-  // we do show the caret when ANSI is not available.
+  // If we're asked to show the first available of ANSI or caret, then we
+  // do show the caret when ANSI is not available.
   const auto value = debugger_sp->GetStopShowColumn();
   if ((value == eStopShowColumnAnsiOrCaret) && !debugger_sp->GetUseColor())
     return true;
@@ -232,8 +232,8 @@
 
 size_t SourceManager::DisplayMoreWithLineNumbers(
     Stream *s, uint32_t count, bool reverse, const SymbolContextList *bp_locs) {
-  // If we get called before anybody has set a default file and line, then try
-  // to figure it out here.
+  // If we get called before anybody has set a default file and line, then
+  // try to figure it out here.
   const bool have_default_file_line = m_last_file_sp && m_last_line > 0;
   if (!m_default_set) {
     FileSpec tmp_spec;
@@ -255,9 +255,9 @@
 
     if (m_last_line > 0) {
       if (reverse) {
-        // If this is the first time we've done a reverse, then back up one more
-        // time so we end
-        // up showing the chunk before the last one we've shown:
+        // If this is the first time we've done a reverse, then back up
+        // one more time so we end up showing the chunk before the last
+        // one we've shown:
         if (m_last_line > m_last_count)
           m_last_line -= m_last_count;
         else
@@ -298,11 +298,11 @@
     TargetSP target_sp(m_target_wp.lock());
 
     if (target_sp) {
-      // If nobody has set the default file and line then try here.  If there's
-      // no executable, then we
-      // will try again later when there is one.  Otherwise, if we can't find it
-      // we won't look again,
-      // somebody will have to set it (for instance when we stop somewhere...)
+      // If nobody has set the default file and line then try here.  If
+      // there's no executable, then we will try again later when there is
+      // one.  Otherwise, if we can't find it we won't look again,
+      // somebody will have to set it (for instance when we stop
+      // somewhere...)
       Module *executable_ptr = target_sp->GetExecutableModulePointer();
       if (executable_ptr) {
         SymbolContextList sc_list;
@@ -405,14 +405,13 @@
           }
         }
       }
-      // Try remapping if m_file_spec does not correspond to an existing file.
+      // Try remapping if m_file_spec does not correspond to an existing
+      // file.
       if (!m_file_spec.Exists()) {
         FileSpec new_file_spec;
-        // Check target specific source remappings first, then fall back to
-        // modules objects can have individual path remappings that were
-        // detected
-        // when the debug info for a module was found.
-        // then
+        // Check target specific source remappings first, then fall back
+        // to modules objects can have individual path remappings that
+        // were detected when the debug info for a module was found. then
         if (target->GetSourcePathMap().FindFile(m_file_spec, new_file_spec) ||
             target->GetImages().FindSourceFile(m_file_spec, new_file_spec)) {
           m_file_spec = new_file_spec;
@@ -493,9 +492,10 @@
 }
 
 void SourceManager::File::UpdateIfNeeded() {
-  // TODO: use host API to sign up for file modifications to anything in our
-  // source cache and only update when we determine a file has been updated.
-  // For now we check each time we want to display info for the file.
+  // TODO: use host API to sign up for file modifications to anything in
+  // our source cache and only update when we determine a file has been
+  // updated. For now we check each time we want to display info for the
+  // file.
   auto curr_mod_time = FileSystem::GetModificationTime(m_file_spec);
 
   if (curr_mod_time != llvm::sys::TimePoint<>() &&
@@ -538,18 +538,18 @@
       if (column && (column < count)) {
         auto debugger_sp = m_debugger_wp.lock();
         if (should_show_stop_column_with_ansi(debugger_sp) && debugger_sp) {
-          // Check if we have any ANSI codes with which to mark this column.
-          // If not, no need to do this work.
+          // Check if we have any ANSI codes with which to mark this
+          // column. If not, no need to do this work.
           auto ansi_prefix_entry = debugger_sp->GetStopShowColumnAnsiPrefix();
           auto ansi_suffix_entry = debugger_sp->GetStopShowColumnAnsiSuffix();
 
-          // We only bother breaking up the line to format the marked column if
-          // there is any marking specified on both sides of the marked column.
-          // In ANSI-terminal-sequence land, there must be a post if there is a
-          // pre format, and vice versa.
+          // We only bother breaking up the line to format the marked
+          // column if there is any marking specified on both sides of the
+          // marked column. In ANSI-terminal-sequence land, there must be
+          // a post if there is a pre format, and vice versa.
           if (ansi_prefix_entry && ansi_suffix_entry) {
-            // Mark the current column with the desired escape sequence for
-            // formatting the column (e.g. underline, inverse, etc.)
+            // Mark the current column with the desired escape sequence
+            // for formatting the column (e.g. underline, inverse, etc.)
 
             // First print the part before the column to mark.
             bytes_written = s->Write(cstr, column - 1);
@@ -581,8 +581,8 @@
         }
       }
 
-      // If we didn't end up displaying the line with ANSI codes for whatever
-      // reason, display it now sans codes.
+      // If we didn't end up displaying the line with ANSI codes for
+      // whatever reason, display it now sans codes.
       if (!displayed_line)
         bytes_written = s->Write(cstr, count);
 
Index: source/Core/Value.cpp
===================================================================
--- source/Core/Value.cpp
+++ source/Core/Value.cpp
@@ -366,10 +366,10 @@
         Target *target = exe_ctx->GetTargetPtr();
         if (target) {
           // Allow expressions to run and evaluate things when the target
-          // has memory sections loaded. This allows you to use "target modules
-          // load"
-          // to load your executable and any shared libraries, then execute
-          // commands where you can look at types in data sections.
+          // has memory sections loaded. This allows you to use "target
+          // modules load" to load your executable and any shared
+          // libraries, then execute commands where you can look at types
+          // in data sections.
           const SectionLoadList &target_sections = target->GetSectionLoadList();
           if (!target_sections.IsEmpty()) {
             address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
@@ -545,8 +545,8 @@
         // section offset address so we might be able to read this from
         // the object files if we don't have a live process. Lets always
         // try and read from the process if we have one though since we
-        // want to read the actual value by setting "prefer_file_cache"
-        // to false.
+        // want to read the actual value by setting "prefer_file_cache" to
+        // false.
         const bool prefer_file_cache = false;
         if (exe_ctx->GetTargetRef().ReadMemory(file_so_addr, prefer_file_cache,
                                                dst, byte_size,
@@ -555,10 +555,10 @@
               "read memory from 0x%" PRIx64 " failed", (uint64_t)address);
         }
       } else {
-        // The execution context might have a NULL process, but it
-        // might have a valid process in the exe_ctx->target, so use
-        // the ExecutionContext::GetProcess accessor to ensure we
-        // get the process if there is one.
+        // The execution context might have a NULL process, but it might
+        // have a valid process in the exe_ctx->target, so use the
+        // ExecutionContext::GetProcess accessor to ensure we get the
+        // process if there is one.
         Process *process = exe_ctx->GetProcessPtr();
 
         if (process) {
Index: source/Core/ValueObject.cpp
===================================================================
--- source/Core/ValueObject.cpp
+++ source/Core/ValueObject.cpp
@@ -146,16 +146,15 @@
   if (update_format)
     did_change_formats = UpdateFormatsIfNeeded();
 
-  // If this is a constant value, then our success is predicated on whether
-  // we have an error or not
+  // If this is a constant value, then our success is predicated on
+  // whether we have an error or not
   if (GetIsConstant()) {
-    // if you are constant, things might still have changed behind your back
-    // (e.g. you are a frozen object and things have changed deeper than you
-    // cared to freeze-dry yourself)
-    // in this case, your value has not changed, but "computed" entries might
-    // have, so you might now have
-    // a different summary, or a different object description. clear these so we
-    // will recompute them
+    // if you are constant, things might still have changed behind your
+    // back (e.g. you are a frozen object and things have changed deeper
+    // than you cared to freeze-dry yourself) in this case, your value has
+    // not changed, but "computed" entries might have, so you might now
+    // have a different summary, or a different object description. clear
+    // these so we will recompute them
     if (update_format && !did_change_formats)
       ClearUserVisibleData(eClearUserVisibleDataItemsSummary |
                            eClearUserVisibleDataItemsDescription);
@@ -167,8 +166,8 @@
   if (NeedsUpdating()) {
     m_update_point.SetUpdated();
 
-    // Save the old value using swap to avoid a string copy which
-    // also will clear our m_value_str
+    // Save the old value using swap to avoid a string copy which also
+    // will clear our m_value_str
     if (m_value_str.empty()) {
       m_old_value_valid = false;
     } else {
@@ -215,8 +214,8 @@
       if (first_update)
         SetValueDidChange(false);
       else if (!m_value_did_change && success == false) {
-        // The value wasn't gotten successfully, so we mark this
-        // as changed if the value used to be valid and now isn't
+        // The value wasn't gotten successfully, so we mark this as
+        // changed if the value used to be valid and now isn't
         SetValueDidChange(value_was_valid);
       } else if (need_compare_checksums) {
         SetValueDidChange(memcmp(&old_checksum[0], &m_value_checksum[0],
@@ -260,9 +259,9 @@
 
 void ValueObject::SetNeedsUpdate() {
   m_update_point.SetNeedsUpdate();
-  // We have to clear the value string here so ConstResult children will notice
-  // if their values are
-  // changed by hand (i.e. with SetValueAsCString).
+  // We have to clear the value string here so ConstResult children will
+  // notice if their values are changed by hand (i.e. with
+  // SetValueAsCString).
   ClearUserVisibleData(eClearUserVisibleDataItemsValue);
 }
 
@@ -557,8 +556,8 @@
 ValueObjectSP ValueObject::GetChildMemberWithName(const ConstString &name,
                                                   bool can_create) {
   // when getting a child by name, it could be buried inside some base
-  // classes (which really aren't part of the expression path), so we
-  // need a vector of indexes that can get us down to the correct child
+  // classes (which really aren't part of the expression path), so we need
+  // a vector of indexes that can get us down to the correct child
   ValueObjectSP child_sp;
 
   // We may need to update our value if we are dynamic
@@ -682,8 +681,8 @@
                                       const TypeSummaryOptions &options) {
   destination.clear();
 
-  // ideally we would like to bail out if passing NULL, but if we do so
-  // we end up not providing the summary for function pointers anymore
+  // ideally we would like to bail out if passing NULL, but if we do so we
+  // end up not providing the summary for function pointers anymore
   if (/*summary_ptr == NULL ||*/ m_is_getting_summary)
     return false;
 
@@ -694,10 +693,10 @@
   if (actual_options.GetLanguage() == lldb::eLanguageTypeUnknown)
     actual_options.SetLanguage(GetPreferredDisplayLanguage());
 
-  // this is a hot path in code and we prefer to avoid setting this string all
-  // too often also clearing out other
-  // information that we might care to see in a crash log. might be useful in
-  // very specific situations though.
+  // this is a hot path in code and we prefer to avoid setting this string
+  // all too often also clearing out other information that we might care
+  // to see in a crash log. might be useful in very specific situations
+  // though.
   /*Host::SetCrashDescriptionWithFormat("Trying to fetch a summary for %s %s.
    Summary provider's description is %s",
    GetTypeName().GetCString(),
@@ -868,8 +867,8 @@
 
 bool ValueObject::SetData(DataExtractor &data, Status &error) {
   error.Clear();
-  // Make sure our value is up to date first so that our location and location
-  // type is valid.
+  // Make sure our value is up to date first so that our location and
+  // location type is valid.
   if (!UpdateValueIfNeeded(false)) {
     error.SetErrorString("unable to read value");
     return false;
@@ -894,8 +893,9 @@
     }
   } break;
   case Value::eValueTypeLoadAddress: {
-    // If it is a load address, then the scalar value is the storage location
-    // of the data, and we have to shove this value down to that load location.
+    // If it is a load address, then the scalar value is the storage
+    // location of the data, and we have to shove this value down to that
+    // load location.
     ExecutionContext exe_ctx(GetExecutionContextRef());
     Process *process = exe_ctx.GetProcessPtr();
     if (process) {
@@ -911,8 +911,8 @@
     }
   } break;
   case Value::eValueTypeHostAddress: {
-    // If it is a host address, then we stuff the scalar as a DataBuffer into
-    // the Value's data.
+    // If it is a host address, then we stuff the scalar as a DataBuffer
+    // into the Value's data.
     DataBufferSP buffer_sp(new DataBufferHeap(byte_size, 0));
     m_data.SetData(buffer_sp, 0);
     data.CopyByteOrderedData(0, byte_size,
@@ -925,7 +925,8 @@
     break;
   }
 
-  // If we have reached this point, then we have successfully changed the value.
+  // If we have reached this point, then we have successfully changed the
+  // value.
   SetNeedsUpdate();
   return true;
 }
@@ -1010,8 +1011,8 @@
     DataExtractor data;
     if (cstr_len > 0 && honor_array) {
       // I am using GetPointeeData() here to abstract the fact that some
-      // ValueObjects are actually frozen pointers in the host
-      // but the pointed-to data lives in the debuggee, and GetPointeeData()
+      // ValueObjects are actually frozen pointers in the host but the
+      // pointed-to data lives in the debuggee, and GetPointeeData()
       // automatically takes care of this
       GetPointeeData(data, 0, cstr_len);
 
@@ -1031,8 +1032,8 @@
       int cstr_len_displayed = -1;
       bool capped_cstr = false;
       // I am using GetPointeeData() here to abstract the fact that some
-      // ValueObjects are actually frozen pointers in the host
-      // but the pointed-to data lives in the debuggee, and GetPointeeData()
+      // ValueObjects are actually frozen pointers in the host but the
+      // pointed-to data lives in the debuggee, and GetPointeeData()
       // automatically takes care of this
       while ((bytes_read = GetPointeeData(data, offset, k_max_buf_size)) > 0) {
         total_bytes_read += bytes_read;
@@ -1113,8 +1114,8 @@
   LanguageRuntime *runtime = process->GetLanguageRuntime(language);
 
   if (runtime == NULL) {
-    // Aw, hell, if the things a pointer, or even just an integer, let's try
-    // ObjC anyway...
+    // Aw, hell, if the things a pointer, or even just an integer, let's
+    // try ObjC anyway...
     CompilerType compiler_type = GetCompilerType();
     if (compiler_type) {
       bool is_signed;
@@ -1175,8 +1176,8 @@
         format_sp.reset(new TypeFormatImpl_Format(my_format));
       if (GetValueAsCString(*format_sp.get(), m_value_str)) {
         if (!m_value_did_change && m_old_value_valid) {
-          // The value was gotten successfully, so we consider the
-          // value as changed if the value string differs
+          // The value was gotten successfully, so we consider the value
+          // as changed if the value string differs
           SetValueDidChange(m_old_value_str != m_value_str);
         }
       }
@@ -1187,8 +1188,8 @@
   return m_value_str.c_str();
 }
 
-// if > 8bytes, 0 is returned. this method should mostly be used
-// to read address values out of pointers
+// if > 8bytes, 0 is returned. this method should mostly be used to read
+// address values out of pointers
 uint64_t ValueObject::GetValueAsUnsigned(uint64_t fail_value, bool *success) {
   // If our byte size is zero this is an aggregate type that has children
   if (CanProvideValue()) {
@@ -1224,10 +1225,10 @@
 }
 
 // if any more "special cases" are added to
-// ValueObject::DumpPrintableRepresentation() please keep
-// this call up to date by returning true for your new special cases. We will
-// eventually move
-// to checking this call result before trying to display special cases
+// ValueObject::DumpPrintableRepresentation() please keep this call up to
+// date by returning true for your new special cases. We will eventually
+// move to checking this call result before trying to display special
+// cases
 bool ValueObject::HasSpecialPrintableRepresentation(
     ValueObjectRepresentationStyle val_obj_display, Format custom_format) {
   Flags flags(GetTypeInfo());
@@ -1275,9 +1276,8 @@
   if (allow_special) {
     if (flags.AnySet(eTypeIsArray | eTypeIsPointer) &&
         val_obj_display == ValueObject::eValueObjectRepresentationStyleValue) {
-      // when being asked to get a printable display an array or pointer type
-      // directly,
-      // try to "do the right thing"
+      // when being asked to get a printable display an array or pointer
+      // type directly, try to "do the right thing"
 
       if (IsCStringContainer(true) &&
           (custom_format == eFormatCString ||
@@ -1405,10 +1405,11 @@
   {
     llvm::StringRef str;
 
-    // this is a local stream that we are using to ensure that the data pointed
-    // to by cstr survives long enough for us to copy it to its destination - it
-    // is necessary to have this temporary storage area for cases where our
-    // desired output is not backed by some other longer-term storage
+    // this is a local stream that we are using to ensure that the data
+    // pointed to by cstr survives long enough for us to copy it to its
+    // destination - it is necessary to have this temporary storage area
+    // for cases where our desired output is not backed by some other
+    // longer-term storage
     StreamString strm;
 
     if (custom_format != eFormatInvalid)
@@ -1485,9 +1486,9 @@
         s.PutCString("<no printable representation>");
     }
 
-    // we should only return false here if we could not do *anything*
-    // even if we have an error message as output, that's a success
-    // from our callers' perspective, so return true
+    // we should only return false here if we could not do *anything* even
+    // if we have an error message as output, that's a success from our
+    // callers' perspective, so return true
     var_success = true;
 
     if (custom_format != eFormatInvalid)
@@ -1563,8 +1564,8 @@
 
 bool ValueObject::SetValueFromCString(const char *value_str, Status &error) {
   error.Clear();
-  // Make sure our value is up to date first so that our location and location
-  // type is valid.
+  // Make sure our value is up to date first so that our location and
+  // location type is valid.
   if (!UpdateValueIfNeeded(false)) {
     error.SetErrorString("unable to read value");
     return false;
@@ -1578,21 +1579,21 @@
   Value::ValueType value_type = m_value.GetValueType();
 
   if (value_type == Value::eValueTypeScalar) {
-    // If the value is already a scalar, then let the scalar change itself:
+    // If the value is already a scalar, then let the scalar change
+    // itself:
     m_value.GetScalar().SetValueFromCString(value_str, encoding, byte_size);
   } else if (byte_size <= 16) {
-    // If the value fits in a scalar, then make a new scalar and again let the
-    // scalar code do the conversion, then figure out where to put the new
-    // value.
+    // If the value fits in a scalar, then make a new scalar and again let
+    // the scalar code do the conversion, then figure out where to put the
+    // new value.
     Scalar new_scalar;
     error = new_scalar.SetValueFromCString(value_str, encoding, byte_size);
     if (error.Success()) {
       switch (value_type) {
       case Value::eValueTypeLoadAddress: {
         // If it is a load address, then the scalar value is the storage
-        // location
-        // of the data, and we have to shove this value down to that load
-        // location.
+        // location of the data, and we have to shove this value down to
+        // that load location.
         ExecutionContext exe_ctx(GetExecutionContextRef());
         Process *process = exe_ctx.GetProcessPtr();
         if (process) {
@@ -1609,8 +1610,8 @@
         }
       } break;
       case Value::eValueTypeHostAddress: {
-        // If it is a host address, then we stuff the scalar as a DataBuffer
-        // into the Value's data.
+        // If it is a host address, then we stuff the scalar as a
+        // DataBuffer into the Value's data.
         DataExtractor new_data;
         new_data.SetByteOrder(m_data.GetByteOrder());
 
@@ -1639,7 +1640,8 @@
     return false;
   }
 
-  // If we have reached this point, then we have successfully changed the value.
+  // If we have reached this point, then we have successfully changed the
+  // value.
   SetNeedsUpdate();
   return true;
 }
@@ -1734,16 +1736,14 @@
   return false;
 }
 
-// This allows you to create an array member using and index
-// that doesn't not fall in the normal bounds of the array.
-// Many times structure can be defined as:
-// struct Collection
-// {
+// This allows you to create an array member using and index that doesn't
+// not fall in the normal bounds of the array. Many times structure can be
+// defined as: struct Collection {
 //     uint32_t item_count;
 //     Item item_array[0];
 // };
-// The size of the "item_array" is 1, but many times in practice
-// there are more items in "item_array".
+// The size of the "item_array" is 1, but many times in practice there are
+// more items in "item_array".
 
 ValueObjectSP ValueObject::GetSyntheticArrayMember(size_t index,
                                                    bool can_create) {
@@ -1757,8 +1757,8 @@
     synthetic_child_sp = GetSyntheticChild(index_const_str);
     if (!synthetic_child_sp) {
       ValueObject *synthetic_child;
-      // We haven't made a synthetic array member for INDEX yet, so
-      // lets make one and cache it for any future reference.
+      // We haven't made a synthetic array member for INDEX yet, so lets
+      // make one and cache it for any future reference.
       synthetic_child = CreateChildAtIndex(0, true, index);
 
       // Cache the value if we got one back...
@@ -1789,8 +1789,8 @@
       if (GetDataExtractor().GetByteOrder() == eByteOrderBig)
         bit_field_offset =
             GetByteSize() * 8 - bit_field_size - bit_field_offset;
-      // We haven't made a synthetic array member for INDEX yet, so
-      // lets make one and cache it for any future reference.
+      // We haven't made a synthetic array member for INDEX yet, so lets
+      // make one and cache it for any future reference.
       ValueObjectChild *synthetic_child = new ValueObjectChild(
           *this, GetCompilerType(), index_const_str, GetByteSize(), 0,
           bit_field_size, bit_field_offset, false, false, eAddressTypeInvalid,
@@ -1884,11 +1884,11 @@
   return synthetic_child_sp;
 }
 
-// your expression path needs to have a leading . or ->
-// (unless it somehow "looks like" an array, in which case it has
-// a leading [ symbol). while the [ is meaningful and should be shown
-// to the user, . and -> are just parser design, but by no means
-// added information for the user.. strip them off
+// your expression path needs to have a leading . or -> (unless it somehow
+// "looks like" an array, in which case it has a leading [ symbol). while
+// the [ is meaningful and should be shown to the user, . and -> are just
+// parser design, but by no means added information for the user.. strip
+// them off
 static const char *SkipLeadingExpressionPathSeparators(const char *expression) {
   if (!expression || !expression[0])
     return expression;
@@ -1918,8 +1918,8 @@
 
     // Cache the value if we got one back...
     if (synthetic_child_sp.get()) {
-      // FIXME: this causes a "real" child to end up with its name changed to
-      // the contents of expression
+      // FIXME: this causes a "real" child to end up with its name changed
+      // to the contents of expression
       AddSyntheticChild(name_const_string, synthetic_child_sp.get());
       synthetic_child_sp->SetName(
           ConstString(SkipLeadingExpressionPathSeparators(expression)));
@@ -2054,11 +2054,10 @@
 
 void ValueObject::GetExpressionPath(Stream &s, bool qualify_cxx_base_classes,
                                     GetExpressionPathFormat epformat) {
-  // synthetic children do not actually "exist" as part of the hierarchy, and
-  // sometimes they are consed up in ways
-  // that don't make sense from an underlying language/API standpoint. So, use a
-  // special code path here to return
-  // something that can hopefully be used in expression
+  // synthetic children do not actually "exist" as part of the hierarchy,
+  // and sometimes they are consed up in ways that don't make sense from
+  // an underlying language/API standpoint. So, use a special code path
+  // here to return something that can hopefully be used in expression
   if (m_is_synthetic_children_generated) {
     UpdateValueIfNeeded();
 
@@ -2091,12 +2090,11 @@
 
   if (is_deref_of_parent &&
       epformat == eGetExpressionPathFormatDereferencePointers) {
-    // this is the original format of GetExpressionPath() producing code like
-    // *(a_ptr).memberName, which is entirely
-    // fine, until you put this into
-    // StackFrame::GetValueForVariableExpressionPath() which prefers to see
-    // a_ptr->memberName.
-    // the eHonorPointers mode is meant to produce strings in this latter format
+    // this is the original format of GetExpressionPath() producing code
+    // like *(a_ptr).memberName, which is entirely fine, until you put
+    // this into StackFrame::GetValueForVariableExpressionPath() which
+    // prefers to see a_ptr->memberName. the eHonorPointers mode is meant
+    // to produce strings in this latter format
     s.PutCString("*(");
   }
 
@@ -2106,8 +2104,8 @@
     parent->GetExpressionPath(s, qualify_cxx_base_classes, epformat);
 
   // if we are a deref_of_parent just because we are synthetic array
-  // members made up to allow ptr[%d] syntax to work in variable
-  // printing, then add our name ([%d]) to the expression path
+  // members made up to allow ptr[%d] syntax to work in variable printing,
+  // then add our name ([%d]) to the expression path
   if (m_is_array_item_for_pointer &&
       epformat == eGetExpressionPathFormatHonorPointers)
     s.PutCString(m_name.AsCString());
@@ -2355,8 +2353,8 @@
         }
 
         // if we are here and options.m_no_synthetic_children is true,
-        // child_valobj_sp is going to be a NULL SP,
-        // so we hit the "else" branch, and return an error
+        // child_valobj_sp is going to be a NULL SP, so we hit the "else"
+        // branch, and return an error
         if (child_valobj_sp.get()) // if it worked, just return
         {
           *reason_to_stop =
@@ -2424,8 +2422,8 @@
         }
 
         // if we are here and options.m_no_synthetic_children is true,
-        // child_valobj_sp is going to be a NULL SP,
-        // so we hit the "else" branch, and return an error
+        // child_valobj_sp is going to be a NULL SP, so we hit the "else"
+        // branch, and return an error
         if (child_valobj_sp.get()) // if it worked, move on
         {
           root = child_valobj_sp;
@@ -2501,14 +2499,14 @@
       llvm::StringRef bracket_expr =
           temp_expression.slice(1, close_bracket_position);
 
-      // If this was an empty expression it would have been caught by the if
-      // above.
+      // If this was an empty expression it would have been caught by the
+      // if above.
       assert(!bracket_expr.empty());
 
       if (!bracket_expr.contains('-')) {
-        // if no separator, this is of the form [N].  Note that this cannot
-        // be an unbounded range of the form [], because that case was handled
-        // above with an unconditional return.
+        // if no separator, this is of the form [N].  Note that this
+        // cannot be an unbounded range of the form [], because that case
+        // was handled above with an unconditional return.
         unsigned long index = 0;
         if (bracket_expr.getAsInteger(0, index)) {
           *reason_to_stop =
@@ -2597,7 +2595,8 @@
             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
             return nullptr;
           } else // we do not know how to expand members of bitfields, so we
-                 // just return and let the caller do any further processing
+                 // just return and let the caller do any further
+                 // processing
           {
             *reason_to_stop = ValueObject::
                 eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
@@ -2631,8 +2630,8 @@
             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
             return nullptr;
           }
-          // if we are here, then root itself is a synthetic VO.. should be good
-          // to go
+          // if we are here, then root itself is a synthetic VO.. should
+          // be good to go
 
           if (!root) {
             *reason_to_stop =
@@ -3030,21 +3029,18 @@
 
 ValueObject::EvaluationPoint::~EvaluationPoint() {}
 
-// This function checks the EvaluationPoint against the current process state.
-// If the current
-// state matches the evaluation point, or the evaluation point is already
-// invalid, then we return
-// false, meaning "no change".  If the current state is different, we update our
-// state, and return
-// true meaning "yes, change".  If we did see a change, we also set
-// m_needs_update to true, so
-// future calls to NeedsUpdate will return true.
-// exe_scope will be set to the current execution context scope.
+// This function checks the EvaluationPoint against the current process
+// state. If the current state matches the evaluation point, or the
+// evaluation point is already invalid, then we return false, meaning "no
+// change".  If the current state is different, we update our state, and
+// return true meaning "yes, change".  If we did see a change, we also set
+// m_needs_update to true, so future calls to NeedsUpdate will return
+// true. exe_scope will be set to the current execution context scope.
 
 bool ValueObject::EvaluationPoint::SyncWithProcessState(
     bool accept_invalid_exe_ctx) {
-  // Start with the target, if it is NULL, then we're obviously not going to get
-  // any further:
+  // Start with the target, if it is NULL, then we're obviously not going
+  // to get any further:
   const bool thread_and_frame_only_if_stopped = true;
   ExecutionContext exe_ctx(
       m_exe_ctx_ref.Lock(thread_and_frame_only_if_stopped));
@@ -3060,9 +3056,9 @@
   // If our stop id is the current stop ID, nothing has changed:
   ProcessModID current_mod_id = process->GetModID();
 
-  // If the current stop id is 0, either we haven't run yet, or the process
-  // state has been cleared.
-  // In either case, we aren't going to be able to sync with the process state.
+  // If the current stop id is 0, either we haven't run yet, or the
+  // process state has been cleared. In either case, we aren't going to be
+  // able to sync with the process state.
   if (current_mod_id.GetStopID() == 0)
     return false;
 
@@ -3080,11 +3076,10 @@
     }
   }
 
-  // Now re-look up the thread and frame in case the underlying objects have
-  // gone away & been recreated.
-  // That way we'll be sure to return a valid exe_scope.
-  // If we used to have a thread or a frame but can't find it anymore, then mark
-  // ourselves as invalid.
+  // Now re-look up the thread and frame in case the underlying objects
+  // have gone away & been recreated. That way we'll be sure to return a
+  // valid exe_scope. If we used to have a thread or a frame but can't
+  // find it anymore, then mark ourselves as invalid.
 
   if (!accept_invalid_exe_ctx) {
     if (m_exe_ctx_ref.HasThreadRef()) {
@@ -3300,10 +3295,8 @@
 
 bool ValueObject::CanProvideValue() {
   // we need to support invalid types as providers of values because some
-  // bare-board
-  // debugging scenarios have no notion of types, but still manage to have raw
-  // numeric
-  // values for things like registers. sigh.
+  // bare-board debugging scenarios have no notion of types, but still
+  // manage to have raw numeric values for things like registers. sigh.
   const CompilerType &type(GetCompilerType());
   return (false == type.IsValid()) ||
          (0 != (type.GetTypeInfo() & eTypeHasValue));
@@ -3360,8 +3353,8 @@
     m_use_synthetic(use_synthetic) {
   if (!in_valobj_sp)
     return;
-  // If the user passes in a value object that is dynamic or synthetic, then
-  // water it down to the static type.
+  // If the user passes in a value object that is dynamic or synthetic,
+  // then water it down to the static type.
   m_root_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable(lldb::eNoDynamicValues, false);
 }
 
Index: source/Core/ValueObjectCast.cpp
===================================================================
--- source/Core/ValueObjectCast.cpp
+++ source/Core/ValueObjectCast.cpp
@@ -71,9 +71,9 @@
     m_value.SetCompilerType(compiler_type);
     SetAddressTypeOfChildren(m_parent->GetAddressTypeOfChildren());
     if (!CanProvideValue()) {
-      // this value object represents an aggregate type whose
-      // children have values, but this object does not. So we
-      // say we are changed if our location has changed.
+      // this value object represents an aggregate type whose children
+      // have values, but this object does not. So we say we are changed
+      // if our location has changed.
       SetValueDidChange(m_value.GetValueType() != old_value.GetValueType() ||
                         m_value.GetScalar() != old_value.GetScalar());
     }
Index: source/Core/ValueObjectChild.cpp
===================================================================
--- source/Core/ValueObjectChild.cpp
+++ source/Core/ValueObjectChild.cpp
@@ -172,8 +172,8 @@
           } else if (addr == 0) {
             m_error.SetErrorString("parent is NULL");
           } else {
-            // Set this object's scalar value to the address of its
-            // value by adding its byte offset to the parent address
+            // Set this object's scalar value to the address of its value
+            // by adding its byte offset to the parent address
             m_value.GetScalar() += GetByteOffset();
           }
         } break;
Index: source/Core/ValueObjectConstResult.cpp
===================================================================
--- source/Core/ValueObjectConstResult.cpp
+++ source/Core/ValueObjectConstResult.cpp
@@ -268,8 +268,8 @@
 
 lldb::ValueObjectSP
 ValueObjectConstResult::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
-  // Always recalculate dynamic values for const results as the memory that
-  // they might point to might have changed at any time.
+  // Always recalculate dynamic values for const results as the memory
+  // that they might point to might have changed at any time.
   if (use_dynamic != eNoDynamicValues) {
     if (!IsDynamic()) {
       ExecutionContext exe_ctx(GetExecutionContextRef());
Index: source/Core/ValueObjectDynamicValue.cpp
===================================================================
--- source/Core/ValueObjectDynamicValue.cpp
+++ source/Core/ValueObjectDynamicValue.cpp
@@ -172,9 +172,8 @@
     }
   }
 
-  // Getting the dynamic value may have run the program a bit, and so marked us
-  // as needing updating, but we really
-  // don't...
+  // Getting the dynamic value may have run the program a bit, and so
+  // marked us as needing updating, but we really don't...
 
   m_update_point.SetUpdated();
 
@@ -191,9 +190,9 @@
     m_type_impl.Clear();
   }
 
-  // If we don't have a dynamic type, then make ourselves just a echo of our
-  // parent.
-  // Or we could return false, and make ourselves an echo of our parent?
+  // If we don't have a dynamic type, then make ourselves just a echo of
+  // our parent. Or we could return false, and make ourselves an echo of
+  // our parent?
   if (!found_dynamic_type) {
     if (m_dynamic_type_info)
       SetValueDidChange(true);
@@ -248,14 +247,14 @@
                 static_cast<void *>(this), GetTypeName().GetCString());
 
   if (m_address.IsValid() && m_dynamic_type_info) {
-    // The variable value is in the Scalar value inside the m_value.
-    // We can point our m_data right to it.
+    // The variable value is in the Scalar value inside the m_value. We
+    // can point our m_data right to it.
     m_error = m_value.GetValueAsData(&exe_ctx, m_data, 0, GetModule().get());
     if (m_error.Success()) {
       if (!CanProvideValue()) {
-        // this value object represents an aggregate type whose
-        // children have values, but this object does not. So we
-        // say we are changed if our location has changed.
+        // this value object represents an aggregate type whose children
+        // have values, but this object does not. So we say we are changed
+        // if our location has changed.
         SetValueDidChange(m_value.GetValueType() != old_value.GetValueType() ||
                           m_value.GetScalar() != old_value.GetScalar());
       }
@@ -287,13 +286,11 @@
     return false;
   }
 
-  // if we are at an offset from our parent, in order to set ourselves correctly
-  // we would need
-  // to change the new value so that it refers to the correct dynamic type. we
-  // choose not to deal
-  // with that - if anything more than a value overwrite is required, you should
-  // be using the
-  // expression parser instead of the value editing facility
+  // if we are at an offset from our parent, in order to set ourselves
+  // correctly we would need to change the new value so that it refers to
+  // the correct dynamic type. we choose not to deal with that - if
+  // anything more than a value overwrite is required, you should be using
+  // the expression parser instead of the value editing facility
   if (my_value != parent_value) {
     // but NULL'ing out a value should always be allowed
     if (strcmp(value_str, "0")) {
@@ -322,13 +319,11 @@
     return false;
   }
 
-  // if we are at an offset from our parent, in order to set ourselves correctly
-  // we would need
-  // to change the new value so that it refers to the correct dynamic type. we
-  // choose not to deal
-  // with that - if anything more than a value overwrite is required, you should
-  // be using the
-  // expression parser instead of the value editing facility
+  // if we are at an offset from our parent, in order to set ourselves
+  // correctly we would need to change the new value so that it refers to
+  // the correct dynamic type. we choose not to deal with that - if
+  // anything more than a value overwrite is required, you should be using
+  // the expression parser instead of the value editing facility
   if (my_value != parent_value) {
     // but NULL'ing out a value should always be allowed
     lldb::offset_t offset = 0;
Index: source/Core/ValueObjectList.cpp
===================================================================
--- source/Core/ValueObjectList.cpp
+++ source/Core/ValueObjectList.cpp
@@ -87,8 +87,8 @@
   collection::iterator pos, end = m_value_objects.end();
 
   for (pos = m_value_objects.begin(); pos != end; ++pos) {
-    // Watch out for NULL objects in our list as the list
-    // might get resized to a specific size and lazily filled in
+    // Watch out for NULL objects in our list as the list might get
+    // resized to a specific size and lazily filled in
     ValueObject *valobj = (*pos).get();
     if (valobj && valobj->GetID() == uid) {
       valobj_sp = *pos;
Index: source/Core/ValueObjectMemory.cpp
===================================================================
--- source/Core/ValueObjectMemory.cpp
+++ source/Core/ValueObjectMemory.cpp
@@ -165,8 +165,8 @@
       llvm_unreachable("Unhandled expression result value kind...");
 
     case Value::eValueTypeScalar:
-      // The variable value is in the Scalar value inside the m_value.
-      // We can point our m_data right to it.
+      // The variable value is in the Scalar value inside the m_value. We
+      // can point our m_data right to it.
       m_error = m_value.GetValueAsData(&exe_ctx, m_data, 0, GetModule().get());
       break;
 
@@ -174,14 +174,15 @@
     case Value::eValueTypeLoadAddress:
     case Value::eValueTypeHostAddress:
       // The DWARF expression result was an address in the inferior
-      // process. If this variable is an aggregate type, we just need
-      // the address as the main value as all child variable objects
-      // will rely upon this location and add an offset and then read
-      // their own values as needed. If this variable is a simple
-      // type, we read all data for it into m_data.
-      // Make sure this type has a value before we try and read it
-
-      // If we have a file address, convert it to a load address if we can.
+      // process. If this variable is an aggregate type, we just need the
+      // address as the main value as all child variable objects will rely
+      // upon this location and add an offset and then read their own
+      // values as needed. If this variable is a simple type, we read all
+      // data for it into m_data. Make sure this type has a value before
+      // we try and read it
+
+      // If we have a file address, convert it to a load address if we
+      // can.
       if (value_type == Value::eValueTypeFileAddress &&
           exe_ctx.GetProcessPtr()) {
         lldb::addr_t load_addr = m_address.GetLoadAddress(target);
@@ -192,14 +193,14 @@
       }
 
       if (!CanProvideValue()) {
-        // this value object represents an aggregate type whose
-        // children have values, but this object does not. So we
-        // say we are changed if our location has changed.
+        // this value object represents an aggregate type whose children
+        // have values, but this object does not. So we say we are changed
+        // if our location has changed.
         SetValueDidChange(value_type != old_value.GetValueType() ||
                           m_value.GetScalar() != old_value.GetScalar());
       } else {
-        // Copy the Value and set the context to use our Variable
-        // so it can extract read its value into m_data appropriately
+        // Copy the Value and set the context to use our Variable so it
+        // can extract read its value into m_data appropriately
         Value value(m_value);
         if (m_type_sp)
           value.SetContext(Value::eContextTypeLLDBType, m_type_sp.get());
Index: source/Core/ValueObjectRegister.cpp
===================================================================
--- source/Core/ValueObjectRegister.cpp
+++ source/Core/ValueObjectRegister.cpp
@@ -319,7 +319,8 @@
 
 bool ValueObjectRegister::SetValueFromCString(const char *value_str,
                                               Status &error) {
-  // The new value will be in the m_data.  Copy that into our register value.
+  // The new value will be in the m_data.  Copy that into our register
+  // value.
   error =
       m_reg_value.SetValueFromString(&m_reg_info, llvm::StringRef(value_str));
   if (error.Success()) {
Index: source/Core/ValueObjectSyntheticFilter.cpp
===================================================================
--- source/Core/ValueObjectSyntheticFilter.cpp
+++ source/Core/ValueObjectSyntheticFilter.cpp
@@ -141,8 +141,8 @@
   m_error.Clear();
 
   if (!m_parent->UpdateValueIfNeeded(false)) {
-    // our parent could not update.. as we are meaningless without a parent,
-    // just stop
+    // our parent could not update.. as we are meaningless without a
+    // parent, just stop
     if (m_parent->GetError().Fail())
       m_error = m_parent->GetError();
     return false;
@@ -171,10 +171,9 @@
     m_children_byindex.Clear();
     m_name_toindex.Clear();
     // usually, an object's value can change but this does not alter its
-    // children count
-    // for a synthetic VO that might indeed happen, so we need to tell the upper
-    // echelons
-    // that they need to come back to us asking for children
+    // children count for a synthetic VO that might indeed happen, so we
+    // need to tell the upper echelons that they need to come back to us
+    // asking for children
     m_children_count_valid = false;
     m_synthetic_children_cache.Clear();
     m_synthetic_children_count = UINT32_MAX;
Index: source/Core/ValueObjectVariable.cpp
===================================================================
--- source/Core/ValueObjectVariable.cpp
+++ source/Core/ValueObjectVariable.cpp
@@ -174,26 +174,21 @@
 
       switch (value_type) {
       case Value::eValueTypeFileAddress:
-        // If this type is a pointer, then its children will be considered load
-        // addresses
-        // if the pointer or reference is dereferenced, but only if the process
-        // is alive.
+        // If this type is a pointer, then its children will be considered
+        // load addresses if the pointer or reference is dereferenced, but
+        // only if the process is alive.
         //
         // There could be global variables like in the following code:
-        // struct LinkedListNode { Foo* foo; LinkedListNode* next; };
-        // Foo g_foo1;
-        // Foo g_foo2;
-        // LinkedListNode g_second_node = { &g_foo2, NULL };
-        // LinkedListNode g_first_node = { &g_foo1, &g_second_node };
+        // struct LinkedListNode { Foo* foo; LinkedListNode* next; }; Foo
+        // g_foo1; Foo g_foo2; LinkedListNode g_second_node = { &g_foo2,
+        // NULL }; LinkedListNode g_first_node = { &g_foo1, &g_second_node
+        // };
         //
-        // When we aren't running, we should be able to look at these variables
-        // using
-        // the "target variable" command. Children of the "g_first_node" always
-        // will
-        // be of the same address type as the parent. But children of the "next"
-        // member of
-        // LinkedListNode will become load addresses if we have a live process,
-        // or remain
+        // When we aren't running, we should be able to look at these
+        // variables using the "target variable" command. Children of the
+        // "g_first_node" always will be of the same address type as the
+        // parent. But children of the "next" member of LinkedListNode
+        // will become load addresses if we have a live process, or remain
         // what a file address if it what a file address.
         if (process_is_alive && is_pointer_or_ref)
           SetAddressTypeOfChildren(eAddressTypeLoad);
@@ -201,13 +196,11 @@
           SetAddressTypeOfChildren(eAddressTypeFile);
         break;
       case Value::eValueTypeHostAddress:
-        // Same as above for load addresses, except children of pointer or refs
-        // are always
-        // load addresses. Host addresses are used to store freeze dried
-        // variables. If this
-        // type is a struct, the entire struct contents will be copied into the
-        // heap of the
-        // LLDB process, but we do not currrently follow any pointers.
+        // Same as above for load addresses, except children of pointer or
+        // refs are always load addresses. Host addresses are used to
+        // store freeze dried variables. If this type is a struct, the
+        // entire struct contents will be copied into the heap of the LLDB
+        // process, but we do not currrently follow any pointers.
         if (is_pointer_or_ref)
           SetAddressTypeOfChildren(eAddressTypeLoad);
         else
@@ -237,11 +230,12 @@
         // process. If this variable is an aggregate type, we just need
         // the address as the main value as all child variable objects
         // will rely upon this location and add an offset and then read
-        // their own values as needed. If this variable is a simple
-        // type, we read all data for it into m_data.
-        // Make sure this type has a value before we try and read it
+        // their own values as needed. If this variable is a simple type,
+        // we read all data for it into m_data. Make sure this type has a
+        // value before we try and read it
 
-        // If we have a file address, convert it to a load address if we can.
+        // If we have a file address, convert it to a load address if we
+        // can.
         if (value_type == Value::eValueTypeFileAddress && process_is_alive) {
           lldb::addr_t file_addr =
               m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
@@ -263,14 +257,14 @@
         }
 
         if (!CanProvideValue()) {
-          // this value object represents an aggregate type whose
-          // children have values, but this object does not. So we
-          // say we are changed if our location has changed.
+          // this value object represents an aggregate type whose children
+          // have values, but this object does not. So we say we are
+          // changed if our location has changed.
           SetValueDidChange(value_type != old_value.GetValueType() ||
                             m_value.GetScalar() != old_value.GetScalar());
         } else {
-          // Copy the Value and set the context to use our Variable
-          // so it can extract read its value into m_data appropriately
+          // Copy the Value and set the context to use our Variable so it
+          // can extract read its value into m_data appropriately
           Value value(m_value);
           value.SetContext(Value::eContextTypeVariable, variable);
           m_error =
@@ -299,14 +293,13 @@
     if (frame) {
       return m_variable_sp->IsInScope(frame);
     } else {
-      // This ValueObject had a frame at one time, but now we
-      // can't locate it, so return false since we probably aren't
-      // in scope.
+      // This ValueObject had a frame at one time, but now we can't locate
+      // it, so return false since we probably aren't in scope.
       return false;
     }
   }
-  // We have a variable that wasn't tied to a frame, which
-  // means it is a global and is always in scope.
+  // We have a variable that wasn't tied to a frame, which means it is a
+  // global and is always in scope.
   return true;
 }
 
Index: source/DataFormatters/FormatManager.cpp
===================================================================
--- source/DataFormatters/FormatManager.cpp
+++ source/DataFormatters/FormatManager.cpp
@@ -494,8 +494,8 @@
   if (valobj.GetNumChildren() == 0)
     return false;
 
-  // ask the type if it has any opinion about this
-  // eLazyBoolCalculate == no opinion; other values should be self explanatory
+  // ask the type if it has any opinion about this eLazyBoolCalculate ==
+  // no opinion; other values should be self explanatory
   CompilerType compiler_type(valobj.GetCompilerType());
   if (compiler_type.IsValid()) {
     switch (compiler_type.ShouldPrintAsOneLiner(&valobj)) {
@@ -531,9 +531,8 @@
       }
     }
 
-    // if we decided to define synthetic children for a type, we probably care
-    // enough
-    // to show them, but avoid nesting children in children
+    // if we decided to define synthetic children for a type, we probably
+    // care enough to show them, but avoid nesting children in children
     if (child_sp->GetSyntheticChildren().get() != nullptr) {
       ValueObjectSP synth_sp(child_sp->GetSyntheticValue());
       // wait.. wat? just get out of here..
@@ -549,9 +548,9 @@
 
     total_children_name_len += child_sp->GetName().GetLength();
 
-    // 50 itself is a "randomly" chosen number - the idea is that
-    // overly long structs should not get this treatment
-    // FIXME: maybe make this a user-tweakable setting?
+    // 50 itself is a "randomly" chosen number - the idea is that overly
+    // long structs should not get this treatment FIXME: maybe make this a
+    // user-tweakable setting?
     if (total_children_name_len > 50)
       return false;
 
@@ -565,8 +564,8 @@
     // if this child has children..
     if (child_sp->GetNumChildren()) {
       // ...and no summary...
-      // (if it had a summary and the summary wanted children, we would have
-      // bailed out anyway
+      // (if it had a summary and the summary wanted children, we would
+      // have bailed out anyway
       //  so this only makes us bail out if this has no summary and we would
       //  then print children)
       if (!child_sp->GetSummaryFormat() && !is_synth_val) // but again only do
Index: source/DataFormatters/StringPrinter.cpp
===================================================================
--- source/DataFormatters/StringPrinter.cpp
+++ source/DataFormatters/StringPrinter.cpp
@@ -26,9 +26,9 @@
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
-// we define this for all values of type but only implement it for those we care
-// about
-// that's good because we get linker errors for any unsupported type
+// we define this for all values of type but only implement it for those
+// we care about that's good because we get linker errors for any
+// unsupported type
 template <lldb_private::formatters::StringPrinter::StringElementType type>
 static StringPrinter::StringPrinterBufferPointer<>
 GetPrintableImpl(uint8_t *buffer, uint8_t *buffer_end, uint8_t *&next);
@@ -163,8 +163,8 @@
         (unsigned char)*(buffer + 2), (unsigned char)*(buffer + 3));
     break;
   default:
-    // this is probably some bogus non-character thing
-    // just print it as-is and hope to sync up again soon
+    // this is probably some bogus non-character thing just print it as-is
+    // and hope to sync up again soon
     retval = {buffer, 1};
     next = buffer + 1;
     return retval;
@@ -217,15 +217,16 @@
     return retval;
   }
 
-  // this should not happen - but just in case.. try to resync at some point
+  // this should not happen - but just in case.. try to resync at some
+  // point
   retval = {buffer, 1};
   next = buffer + 1;
   return retval;
 }
 
-// Given a sequence of bytes, this function returns:
-// a sequence of bytes to actually print out + a length
-// the following unscanned position of the buffer is in next
+// Given a sequence of bytes, this function returns: a sequence of bytes
+// to actually print out + a length the following unscanned position of
+// the buffer is in next
 static StringPrinter::StringPrinterBufferPointer<>
 GetPrintable(StringPrinter::StringElementType type, uint8_t *buffer,
              uint8_t *buffer_end, uint8_t *&next) {
@@ -320,9 +321,9 @@
       utf8_data_ptr =
           (llvm::UTF8 *)utf8_data_buffer_sp->GetBytes();
     } else {
-      // just copy the pointers - the cast is necessary to make the compiler
-      // happy
-      // but this should only happen if we are reading UTF8 data
+      // just copy the pointers - the cast is necessary to make the
+      // compiler happy but this should only happen if we are reading UTF8
+      // data
       utf8_data_ptr = const_cast<llvm::UTF8 *>(
           reinterpret_cast<const llvm::UTF8 *>(data_ptr));
       utf8_data_end_ptr = const_cast<llvm::UTF8 *>(
@@ -343,9 +344,10 @@
                     GetPrintableElementType::UTF8);
     }
 
-    // since we tend to accept partial data (and even partially malformed data)
-    // we might end up with no NULL terminator before the end_ptr
-    // hence we need to take a slower route and ensure we stay within boundaries
+    // since we tend to accept partial data (and even partially malformed
+    // data) we might end up with no NULL terminator before the end_ptr
+    // hence we need to take a slower route and ensure we stay within
+    // boundaries
     for (; utf8_data_ptr < utf8_data_end_ptr;) {
       if (zero_is_terminator && !*utf8_data_ptr)
         break;
@@ -357,8 +359,8 @@
         auto printable_bytes = printable.GetBytes();
         auto printable_size = printable.GetSize();
         if (!printable_bytes || !next_data) {
-          // GetPrintable() failed on us - print one byte in a desperate resync
-          // attempt
+          // GetPrintable() failed on us - print one byte in a desperate
+          // resync attempt
           printable_bytes = utf8_data_ptr;
           printable_size = 1;
           next_data = utf8_data_ptr + 1;
@@ -471,9 +473,10 @@
                   ASCII);
   }
 
-  // since we tend to accept partial data (and even partially malformed data)
-  // we might end up with no NULL terminator before the end_ptr
-  // hence we need to take a slower route and ensure we stay within boundaries
+  // since we tend to accept partial data (and even partially malformed
+  // data) we might end up with no NULL terminator before the end_ptr
+  // hence we need to take a slower route and ensure we stay within
+  // boundaries
   for (uint8_t *data = buffer_sp->GetBytes(); *data && (data < data_end);) {
     if (escape_non_printables) {
       uint8_t *next_data = nullptr;
@@ -481,8 +484,8 @@
       auto printable_bytes = printable.GetBytes();
       auto printable_size = printable.GetSize();
       if (!printable_bytes || !next_data) {
-        // GetPrintable() failed on us - print one byte in a desperate resync
-        // attempt
+        // GetPrintable() failed on us - print one byte in a desperate
+        // resync attempt
         printable_bytes = data;
         printable_size = 1;
         next_data = data + 1;
Index: source/DataFormatters/TypeFormat.cpp
===================================================================
--- source/DataFormatters/TypeFormat.cpp
+++ source/DataFormatters/TypeFormat.cpp
@@ -70,15 +70,15 @@
     } else {
       CompilerType compiler_type = value.GetCompilerType();
       if (compiler_type) {
-        // put custom bytes to display in the DataExtractor to override the
-        // default value logic
+        // put custom bytes to display in the DataExtractor to override
+        // the default value logic
         if (GetFormat() == eFormatCString) {
           lldb_private::Flags type_flags(compiler_type.GetTypeInfo(
               NULL)); // disambiguate w.r.t. TypeFormatImpl::Flags
           if (type_flags.Test(eTypeIsPointer) &&
               !type_flags.Test(eTypeIsObjC)) {
-            // if we are dumping a pointer as a c-string, get the pointee data
-            // as a string
+            // if we are dumping a pointer as a c-string, get the pointee
+            // data as a string
             TargetSP target_sp(valobj->GetTargetSP());
             if (target_sp) {
               size_t max_len = target_sp->GetMaximumSizeOfStringSummary();
@@ -111,12 +111,12 @@
             valobj->GetBitfieldBitSize(),   // Bitfield bit size
             valobj->GetBitfieldBitOffset(), // Bitfield bit offset
             exe_scope);
-        // Given that we do not want to set the ValueObject's m_error
-        // for a formatting error (or else we wouldn't be able to reformat
+        // Given that we do not want to set the ValueObject's m_error for
+        // a formatting error (or else we wouldn't be able to reformat
         // until a next update), an empty string is treated as a "false"
         // return from here, but that's about as severe as we get
-        // CompilerType::DumpTypeValue() should always return
-        // something, even if that something is an error message
+        // CompilerType::DumpTypeValue() should always return something,
+        // even if that something is an error message
         dest = sstr.GetString();
       }
     }
Index: source/DataFormatters/ValueObjectPrinter.cpp
===================================================================
--- source/DataFormatters/ValueObjectPrinter.cpp
+++ source/DataFormatters/ValueObjectPrinter.cpp
@@ -230,13 +230,13 @@
 
 void ValueObjectPrinter::PrintDecl() {
   bool show_type = true;
-  // if we are at the root-level and been asked to hide the root's type, then
-  // hide it
+  // if we are at the root-level and been asked to hide the root's type,
+  // then hide it
   if (m_curr_depth == 0 && m_options.m_hide_root_type)
     show_type = false;
   else
-    // otherwise decide according to the usual rules (asked to show types -
-    // always at the root level)
+    // otherwise decide according to the usual rules (asked to show types
+    // - always at the root level)
     show_type = m_options.m_show_types ||
                 (m_curr_depth == 0 && !m_options.m_flat_output);
 
@@ -244,8 +244,8 @@
 
   // always show the type at the root level if it is invalid
   if (show_type) {
-    // Some ValueObjects don't have types (like registers sets). Only print
-    // the type if there is one to print
+    // Some ValueObjects don't have types (like registers sets). Only
+    // print the type if there is one to print
     ConstString type_name;
     if (m_compiler_type.IsValid()) {
       if (m_options.m_use_type_display_name)
@@ -289,8 +289,8 @@
   bool decl_printed = false;
   if (!m_options.m_decl_printing_helper) {
     // if the user didn't give us a custom helper, pick one based upon the
-    // language, either the one that this printer is bound to, or the preferred
-    // one for the ValueObject
+    // language, either the one that this printer is bound to, or the
+    // preferred one for the ValueObject
     lldb::LanguageType lang_type =
         (m_options.m_varformat_language == lldb::eLanguageTypeUnknown)
             ? m_valobj->GetPreferredDisplayLanguage()
@@ -356,8 +356,8 @@
                                               std::string &summary,
                                               std::string &error) {
   lldb::Format format = m_options.m_format;
-  // if I am printing synthetized elements, apply the format to those elements
-  // only
+  // if I am printing synthetized elements, apply the format to those
+  // elements only
   if (m_options.m_pointer_as_array)
     m_valobj->GetValueAsCString(lldb::eFormatDefault, value);
   else if (format != eFormatDefault && format != m_valobj->GetFormat())
@@ -401,13 +401,11 @@
       GetValueSummaryError(m_value, m_summary, m_error);
     }
     if (m_error.size()) {
-      // we need to support scenarios in which it is actually fine for a value
-      // to have no type
-      // but - on the other hand - if we get an error *AND* have no type, we try
-      // to get out
-      // gracefully, since most often that combination means "could not resolve
-      // a type"
-      // and the default failure mode is quite ugly
+      // we need to support scenarios in which it is actually fine for a
+      // value to have no type but - on the other hand - if we get an
+      // error *AND* have no type, we try to get out gracefully, since
+      // most often that combination means "could not resolve a type" and
+      // the default failure mode is quite ugly
       if (!m_compiler_type.IsValid()) {
         m_stream->Printf(" <could not resolve type>");
         return false;
@@ -418,8 +416,8 @@
     } else {
       // Make sure we have a value and make sure the summary didn't
       // specify that the value should not be printed - and do not print
-      // the value if this thing is nil
-      // (but show the value if the user passes a format explicitly)
+      // the value if this thing is nil (but show the value if the user
+      // passes a format explicitly)
       TypeSummaryImpl *entry = GetSummaryFormatter();
       if (!IsNil() && !IsUninitialized() && !m_value.empty() &&
           (entry == NULL || (entry->DoesPrintValue(m_valobj) ||
@@ -457,7 +455,8 @@
       else
         object_desc = GetDescriptionForDisplay();
       if (object_desc && *object_desc) {
-        // If the description already ends with a \n don't add another one.
+        // If the description already ends with a \n don't add another
+        // one.
         size_t object_end = strlen(object_desc) - 1;
         if (object_desc[object_end] == '\n')
             m_stream->Printf("%s", object_desc);
@@ -494,8 +493,8 @@
   if (is_uninit)
     return false;
 
-  // if the user has specified an element count, always print children
-  // as it is explicit user demand being honored
+  // if the user has specified an element count, always print children as
+  // it is explicit user demand being honored
   if (m_options.m_pointer_as_array)
     return true;
 
@@ -505,17 +504,17 @@
     return false;
 
   if (is_failed_description || m_curr_depth < m_options.m_max_depth) {
-    // We will show children for all concrete types. We won't show
-    // pointer contents unless a pointer depth has been specified.
-    // We won't reference contents unless the reference is the
-    // root object (depth of zero).
+    // We will show children for all concrete types. We won't show pointer
+    // contents unless a pointer depth has been specified. We won't
+    // reference contents unless the reference is the root object (depth
+    // of zero).
 
-    // Use a new temporary pointer depth in case we override the
-    // current pointer depth below...
+    // Use a new temporary pointer depth in case we override the current
+    // pointer depth below...
 
     if (is_ptr || is_ref) {
-      // We have a pointer or reference whose value is an address.
-      // Make sure that address is not NULL
+      // We have a pointer or reference whose value is an address. Make
+      // sure that address is not NULL
       AddressType ptr_address_type;
       if (m_valobj->GetPointerValue(&ptr_address_type) == 0)
         return false;
@@ -654,7 +653,8 @@
 ValueObjectSP ValueObjectPrinter::GenerateChild(ValueObject *synth_valobj,
                                                 size_t idx) {
   if (m_options.m_pointer_as_array) {
-    // if generating pointer-as-array children, use GetSyntheticArrayMember
+    // if generating pointer-as-array children, use
+    // GetSyntheticArrayMember
     return synth_valobj->GetSyntheticArrayMember(
         PhysicalIndexForLogicalIndex(
             m_options.m_pointer_as_array.m_base_element,
@@ -759,8 +759,8 @@
 void ValueObjectPrinter::PrintChildrenIfNeeded(bool value_printed,
                                                bool summary_printed) {
   // this flag controls whether we tried to display a description for this
-  // object and failed
-  // if that happens, we want to display the children, if any
+  // object and failed if that happens, we want to display the children,
+  // if any
   bool is_failed_description =
       !PrintObjectDescriptionIfNeeded(value_printed, summary_printed);
 
@@ -779,7 +779,8 @@
   if (print_children && is_instance_ptr) {
     instance_ptr_value = m_valobj->GetValueAsUnsigned(0);
     if (m_printed_instance_pointers->count(instance_ptr_value)) {
-      // we already printed this instance-is-pointer thing, so don't expand it
+      // we already printed this instance-is-pointer thing, so don't
+      // expand it
       m_stream->PutCString(" {...}\n");
 
       // we're done here - get out fast
Index: source/DataFormatters/VectorType.cpp
===================================================================
--- source/DataFormatters/VectorType.cpp
+++ source/DataFormatters/VectorType.cpp
@@ -156,10 +156,9 @@
     return eFormatHex;
 
   case lldb::eFormatDefault: {
-    // special case the (default, char) combination to actually display as an
-    // integer value
-    // most often, you won't want to see the ASCII characters... (and if you do,
-    // eFormatChar is a keystroke away)
+    // special case the (default, char) combination to actually display as
+    // an integer value most often, you won't want to see the ASCII
+    // characters... (and if you do, eFormatChar is a keystroke away)
     bool is_char = element_type.IsCharType();
     bool is_signed = false;
     element_type.IsIntegerType(is_signed);
Index: source/Expression/DWARFExpression.cpp
===================================================================
--- source/Expression/DWARFExpression.cpp
+++ source/Expression/DWARFExpression.cpp
@@ -697,16 +697,16 @@
 }
 
 // bool
-// DWARFExpression::LocationListContainsLoadAddress (Process* process, const
-// Address &addr) const
+// DWARFExpression::LocationListContainsLoadAddress (Process* process,
+// const Address &addr) const
 //{
 //    return LocationListContainsLoadAddress(process,
 //    addr.GetLoadAddress(process));
 //}
 //
 // bool
-// DWARFExpression::LocationListContainsLoadAddress (Process* process, addr_t
-// load_addr) const
+// DWARFExpression::LocationListContainsLoadAddress (Process* process,
+// addr_t load_addr) const
 //{
 //    if (load_addr == LLDB_INVALID_ADDRESS)
 //        return false;
@@ -991,10 +991,10 @@
 
     if (op == DW_OP_addr) {
       const uint32_t addr_byte_size = m_data.GetAddressByteSize();
-      // We have to make a copy of the data as we don't know if this
-      // data is from a read only memory mapped buffer, so we duplicate
-      // all of the data first, then modify it, and if all goes well,
-      // we then replace the data for this expression
+      // We have to make a copy of the data as we don't know if this data
+      // is from a read only memory mapped buffer, so we duplicate all of
+      // the data first, then modify it, and if all goes well, we then
+      // replace the data for this expression
 
       // So first we copy the data into a heap buffer
       std::unique_ptr<DataBufferHeap> head_data_ap(
@@ -1010,8 +1010,8 @@
         return false;
 
       // All went well, so now we can reset the data using a shared
-      // pointer to the heap data so "m_data" will now correctly
-      // manage the heap data.
+      // pointer to the heap data so "m_data" will now correctly manage
+      // the heap data.
       m_data.SetData(DataBufferSP(head_data_ap.release()));
       return true;
     } else {
@@ -1025,9 +1025,9 @@
 }
 
 bool DWARFExpression::ContainsThreadLocalStorage() const {
-  // We are assuming for now that any thread local variable will not
-  // have a location list. This has been true for all thread local
-  // variables we have seen so far produced by any compiler.
+  // We are assuming for now that any thread local variable will not have
+  // a location list. This has been true for all thread local variables we
+  // have seen so far produced by any compiler.
   if (IsLocationList())
     return false;
   lldb::offset_t offset = 0;
@@ -1048,24 +1048,24 @@
     lldb::ModuleSP new_module_sp,
     std::function<lldb::addr_t(lldb::addr_t file_addr)> const
         &link_address_callback) {
-  // We are assuming for now that any thread local variable will not
-  // have a location list. This has been true for all thread local
-  // variables we have seen so far produced by any compiler.
+  // We are assuming for now that any thread local variable will not have
+  // a location list. This has been true for all thread local variables we
+  // have seen so far produced by any compiler.
   if (IsLocationList())
     return false;
 
   const uint32_t addr_byte_size = m_data.GetAddressByteSize();
-  // We have to make a copy of the data as we don't know if this
-  // data is from a read only memory mapped buffer, so we duplicate
-  // all of the data first, then modify it, and if all goes well,
-  // we then replace the data for this expression
+  // We have to make a copy of the data as we don't know if this data is
+  // from a read only memory mapped buffer, so we duplicate all of the
+  // data first, then modify it, and if all goes well, we then replace the
+  // data for this expression
 
   // So first we copy the data into a heap buffer
   std::shared_ptr<DataBufferHeap> heap_data_sp(
       new DataBufferHeap(m_data.GetDataStart(), m_data.GetByteSize()));
 
-  // Make en encoder so we can write the address into the buffer using
-  // the correct byte order (endianness)
+  // Make en encoder so we can write the address into the buffer using the
+  // correct byte order (endianness)
   DataEncoder encoder(heap_data_sp->GetBytes(), heap_data_sp->GetByteSize(),
                       m_data.GetByteOrder(), addr_byte_size);
 
@@ -1080,8 +1080,7 @@
     switch (op) {
     case DW_OP_const4u:
       // Remember the const offset in case we later have a
-      // DW_OP_form_tls_address
-      // or DW_OP_GNU_push_tls_address
+      // DW_OP_form_tls_address or DW_OP_GNU_push_tls_address
       const_offset = offset;
       const_value = m_data.GetU32(&offset);
       decoded_data = true;
@@ -1090,8 +1089,7 @@
 
     case DW_OP_const8u:
       // Remember the const offset in case we later have a
-      // DW_OP_form_tls_address
-      // or DW_OP_GNU_push_tls_address
+      // DW_OP_form_tls_address or DW_OP_GNU_push_tls_address
       const_offset = offset;
       const_value = m_data.GetU64(&offset);
       decoded_data = true;
@@ -1100,22 +1098,17 @@
 
     case DW_OP_form_tls_address:
     case DW_OP_GNU_push_tls_address:
-      // DW_OP_form_tls_address and DW_OP_GNU_push_tls_address must be preceded
-      // by
-      // a file address on the stack. We assume that DW_OP_const4u or
-      // DW_OP_const8u
-      // is used for these values, and we check that the last opcode we got
-      // before
-      // either of these was DW_OP_const4u or DW_OP_const8u. If so, then we can
-      // link
-      // the value accodingly. For Darwin, the value in the DW_OP_const4u or
+      // DW_OP_form_tls_address and DW_OP_GNU_push_tls_address must be
+      // preceded by a file address on the stack. We assume that
+      // DW_OP_const4u or DW_OP_const8u is used for these values, and we
+      // check that the last opcode we got before either of these was
+      // DW_OP_const4u or DW_OP_const8u. If so, then we can link the value
+      // accodingly. For Darwin, the value in the DW_OP_const4u or
       // DW_OP_const8u is the file address of a structure that contains a
-      // function
-      // pointer, the pthread key and the offset into the data pointed to by the
-      // pthread key. So we must link this address and also set the module of
-      // this
-      // expression to the new_module_sp so we can resolve the file address
-      // correctly
+      // function pointer, the pthread key and the offset into the data
+      // pointed to by the pthread key. So we must link this address and
+      // also set the module of this expression to the new_module_sp so we
+      // can resolve the file address correctly
       if (const_byte_size > 0) {
         lldb::addr_t linked_file_addr = link_address_callback(const_value);
         if (linked_file_addr == LLDB_INVALID_ADDRESS)
@@ -1143,10 +1136,9 @@
     }
   }
 
-  // If we linked the TLS address correctly, update the module so that when the
-  // expression
-  // is evaluated it can resolve the file address to a load address and read the
-  // TLS data
+  // If we linked the TLS address correctly, update the module so that
+  // when the expression is evaluated it can resolve the file address to a
+  // load address and read the TLS data
   m_module_wp = new_module_sp;
   m_data.SetData(heap_data_sp);
   return true;
@@ -1385,8 +1377,9 @@
     }
     switch (op) {
     //----------------------------------------------------------------------
-    // The DW_OP_addr operation has a single operand that encodes a machine
-    // address and whose size is the size of an address on the target machine.
+    // The DW_OP_addr operation has a single operand that encodes a
+    // machine address and whose size is the size of an address on the
+    // target machine.
     //----------------------------------------------------------------------
     case DW_OP_addr:
       stack.push_back(Scalar(opcodes.GetAddress(&offset)));
@@ -1399,9 +1392,9 @@
     //  DW_OP_addr(0x1000)
     // If this address resides in a shared library, then this virtual
     // address won't make sense when it is evaluated in the context of a
-    // running process where shared libraries have been slid. To account for
-    // this, this new address type where we can store the section pointer
-    // and a 4 byte offset.
+    // running process where shared libraries have been slid. To account
+    // for this, this new address type where we can store the section
+    // pointer and a 4 byte offset.
     //----------------------------------------------------------------------
     //      case DW_OP_addr_sect_offset4:
     //          {
@@ -1498,15 +1491,15 @@
     // OPCODE: DW_OP_deref_size
     // OPERANDS: 1
     //  1 - uint8_t that specifies the size of the data to dereference.
-    // DESCRIPTION: Behaves like the DW_OP_deref operation: it pops the top
-    // stack entry and treats it as an address. The value retrieved from that
-    // address is pushed. In the DW_OP_deref_size operation, however, the
-    // size in bytes of the data retrieved from the dereferenced address is
-    // specified by the single operand. This operand is a 1-byte unsigned
-    // integral constant whose value may not be larger than the size of an
-    // address on the target machine. The data retrieved is zero extended
-    // to the size of an address on the target machine before being pushed
-    // on the expression stack.
+    // DESCRIPTION: Behaves like the DW_OP_deref operation: it pops the
+    // top stack entry and treats it as an address. The value retrieved
+    // from that address is pushed. In the DW_OP_deref_size operation,
+    // however, the size in bytes of the data retrieved from the
+    // dereferenced address is specified by the single operand. This
+    // operand is a 1-byte unsigned integral constant whose value may not
+    // be larger than the size of an address on the target machine. The
+    // data retrieved is zero extended to the size of an address on the
+    // target machine before being pushed on the expression stack.
     //----------------------------------------------------------------------
     case DW_OP_deref_size: {
       if (stack.empty()) {
@@ -1522,11 +1515,10 @@
         void *src = (void *)stack.back().GetScalar().ULongLong();
         intptr_t ptr;
         ::memcpy(&ptr, src, sizeof(void *));
-        // I can't decide whether the size operand should apply to the bytes in
-        // their
-        // lldb-host endianness or the target endianness.. I doubt this'll ever
-        // come up
-        // but I'll opt for assuming big endian regardless.
+        // I can't decide whether the size operand should apply to the
+        // bytes in their lldb-host endianness or the target endianness..
+        // I doubt this'll ever come up but I'll opt for assuming big
+        // endian regardless.
         switch (size) {
         case 1:
           ptr = ptr & 0xff;
@@ -1540,10 +1532,9 @@
         case 4:
           ptr = ptr & 0xffffffff;
           break;
-        // the casts are added to work around the case where intptr_t is a 32
-        // bit quantity;
-        // presumably we won't hit the 5..7 cases if (void*) is 32-bits in this
-        // program.
+        // the casts are added to work around the case where intptr_t is a
+        // 32 bit quantity; presumably we won't hit the 5..7 cases if
+        // (void*) is 32-bits in this program.
         case 5:
           ptr = (intptr_t)ptr & 0xffffffffffULL;
           break;
@@ -1642,14 +1633,14 @@
     //----------------------------------------------------------------------
     // OPCODE: DW_OP_xderef
     // OPERANDS: none
-    // DESCRIPTION: Provides an extended dereference mechanism. The entry at
-    // the top of the stack is treated as an address. The second stack entry
-    // is treated as an "address space identifier" for those architectures
-    // that support multiple address spaces. The top two stack elements are
-    // popped, a data item is retrieved through an implementation-defined
-    // address calculation and pushed as the new stack top. The size of the
-    // data retrieved from the dereferenced address is the size of an address
-    // on the target machine.
+    // DESCRIPTION: Provides an extended dereference mechanism. The entry
+    // at the top of the stack is treated as an address. The second stack
+    // entry is treated as an "address space identifier" for those
+    // architectures that support multiple address spaces. The top two
+    // stack elements are popped, a data item is retrieved through an
+    // implementation-defined address calculation and pushed as the new
+    // stack top. The size of the data retrieved from the dereferenced
+    // address is the size of an address on the target machine.
     //----------------------------------------------------------------------
     case DW_OP_xderef:
       if (error_ptr)
@@ -1660,17 +1651,16 @@
     // All DW_OP_constXXX opcodes have a single operand as noted below:
     //
     // Opcode           Operand 1
-    // ---------------  ----------------------------------------------------
-    // DW_OP_const1u    1-byte unsigned integer constant
-    // DW_OP_const1s    1-byte signed integer constant
-    // DW_OP_const2u    2-byte unsigned integer constant
-    // DW_OP_const2s    2-byte signed integer constant
-    // DW_OP_const4u    4-byte unsigned integer constant
-    // DW_OP_const4s    4-byte signed integer constant
-    // DW_OP_const8u    8-byte unsigned integer constant
-    // DW_OP_const8s    8-byte signed integer constant
-    // DW_OP_constu     unsigned LEB128 integer constant
-    // DW_OP_consts     signed LEB128 integer constant
+    // ---------------
+    // ---------------------------------------------------- DW_OP_const1u
+    // 1-byte unsigned integer constant DW_OP_const1s    1-byte signed
+    // integer constant DW_OP_const2u    2-byte unsigned integer constant
+    // DW_OP_const2s    2-byte signed integer constant DW_OP_const4u
+    // 4-byte unsigned integer constant DW_OP_const4s    4-byte signed
+    // integer constant DW_OP_const8u    8-byte unsigned integer constant
+    // DW_OP_const8s    8-byte signed integer constant DW_OP_constu
+    // unsigned LEB128 integer constant DW_OP_consts     signed LEB128
+    // integer constant
     //----------------------------------------------------------------------
     case DW_OP_const1u:
       stack.push_back(Scalar((uint8_t)opcodes.GetU8(&offset)));
@@ -1749,9 +1739,9 @@
 
     //----------------------------------------------------------------------
     // OPCODE: DW_OP_pick
-    // OPERANDS: uint8_t index into the current stack
-    // DESCRIPTION: The stack entry with the specified index (0 through 255,
-    // inclusive) is pushed on the stack
+    // OPERANDS: uint8_t index into the current stack DESCRIPTION: The
+    // stack entry with the specified index (0 through 255, inclusive) is
+    // pushed on the stack
     //----------------------------------------------------------------------
     case DW_OP_pick: {
       uint8_t pick_idx = opcodes.GetU8(&offset);
@@ -1790,8 +1780,8 @@
     // OPERANDS: none
     // DESCRIPTION: Rotates the first three stack entries. The entry at
     // the top of the stack becomes the third stack entry, the second
-    // entry becomes the top of the stack, and the third entry becomes
-    // the second entry.
+    // entry becomes the top of the stack, and the third entry becomes the
+    // second entry.
     //----------------------------------------------------------------------
     case DW_OP_rot:
       if (stack.size() < 3) {
@@ -1812,8 +1802,8 @@
     // OPCODE: DW_OP_abs
     // OPERANDS: none
     // DESCRIPTION: pops the top stack entry, interprets it as a signed
-    // value and pushes its absolute value. If the absolute value can not be
-    // represented, the result is undefined.
+    // value and pushes its absolute value. If the absolute value can not
+    // be represented, the result is undefined.
     //----------------------------------------------------------------------
     case DW_OP_abs:
       if (stack.empty()) {
@@ -1852,9 +1842,9 @@
     //----------------------------------------------------------------------
     // OPCODE: DW_OP_div
     // OPERANDS: none
-    // DESCRIPTION: pops the top two stack values, divides the former second
-    // entry by the former top of the stack using signed division, and
-    // pushes the result.
+    // DESCRIPTION: pops the top two stack values, divides the former
+    // second entry by the former top of the stack using signed division,
+    // and pushes the result.
     //----------------------------------------------------------------------
     case DW_OP_div:
       if (stack.size() < 2) {
@@ -1884,8 +1874,9 @@
     //----------------------------------------------------------------------
     // OPCODE: DW_OP_minus
     // OPERANDS: none
-    // DESCRIPTION: pops the top two stack values, subtracts the former top
-    // of the stack from the former second entry, and pushes the result.
+    // DESCRIPTION: pops the top two stack values, subtracts the former
+    // top of the stack from the former second entry, and pushes the
+    // result.
     //----------------------------------------------------------------------
     case DW_OP_minus:
       if (stack.size() < 2) {
@@ -2006,8 +1997,8 @@
     //----------------------------------------------------------------------
     // OPCODE: DW_OP_plus
     // OPERANDS: none
-    // DESCRIPTION: pops the top two stack entries, adds them together, and
-    // pushes the result.
+    // DESCRIPTION: pops the top two stack entries, adds them together,
+    // and pushes the result.
     //----------------------------------------------------------------------
     case DW_OP_plus:
       if (stack.size() < 2) {
@@ -2025,8 +2016,8 @@
     //----------------------------------------------------------------------
     // OPCODE: DW_OP_plus_uconst
     // OPERANDS: none
-    // DESCRIPTION: pops the top stack entry, adds it to the unsigned LEB128
-    // constant operand and pushes the result.
+    // DESCRIPTION: pops the top stack entry, adds it to the unsigned
+    // LEB128 constant operand and pushes the result.
     //----------------------------------------------------------------------
     case DW_OP_plus_uconst:
       if (stack.empty()) {
@@ -2069,9 +2060,10 @@
     //----------------------------------------------------------------------
     // OPCODE: DW_OP_shr
     // OPERANDS: none
-    // DESCRIPTION: pops the top two stack entries, shifts the former second
-    // entry right logically (filling with zero bits) by the number of bits
-    // specified by the former top of the stack, and pushes the result.
+    // DESCRIPTION: pops the top two stack entries, shifts the former
+    // second entry right logically (filling with zero bits) by the number
+    // of bits specified by the former top of the stack, and pushes the
+    // result.
     //----------------------------------------------------------------------
     case DW_OP_shr:
       if (stack.size() < 2) {
@@ -2094,10 +2086,10 @@
     //----------------------------------------------------------------------
     // OPCODE: DW_OP_shra
     // OPERANDS: none
-    // DESCRIPTION: pops the top two stack entries, shifts the former second
-    // entry right arithmetically (divide the magnitude by 2, keep the same
-    // sign for the result) by the number of bits specified by the former
-    // top of the stack, and pushes the result.
+    // DESCRIPTION: pops the top two stack entries, shifts the former
+    // second entry right arithmetically (divide the magnitude by 2, keep
+    // the same sign for the result) by the number of bits specified by
+    // the former top of the stack, and pushes the result.
     //----------------------------------------------------------------------
     case DW_OP_shra:
       if (stack.size() < 2) {
@@ -2135,10 +2127,10 @@
     //----------------------------------------------------------------------
     // OPCODE: DW_OP_skip
     // OPERANDS: int16_t
-    // DESCRIPTION:  An unconditional branch. Its single operand is a 2-byte
-    // signed integer constant. The 2-byte constant is the number of bytes
-    // of the DWARF expression to skip forward or backward from the current
-    // operation, beginning after the 2-byte constant.
+    // DESCRIPTION:  An unconditional branch. Its single operand is a
+    // 2-byte signed integer constant. The 2-byte constant is the number
+    // of bytes of the DWARF expression to skip forward or backward from
+    // the current operation, beginning after the 2-byte constant.
     //----------------------------------------------------------------------
     case DW_OP_skip: {
       int16_t skip_offset = (int16_t)opcodes.GetU16(&offset);
@@ -2190,10 +2182,9 @@
     // OPCODE: DW_OP_eq
     // OPERANDS: none
     // DESCRIPTION: pops the top two stack values, compares using the
-    // equals (==) operator.
-    // STACK RESULT: push the constant value 1 onto the stack if the result
-    // of the operation is true or the constant value 0 if the result of the
-    // operation is false.
+    // equals (==) operator. STACK RESULT: push the constant value 1 onto
+    // the stack if the result of the operation is true or the constant
+    // value 0 if the result of the operation is false.
     //----------------------------------------------------------------------
     case DW_OP_eq:
       if (stack.size() < 2) {
@@ -2213,10 +2204,10 @@
     // OPCODE: DW_OP_ge
     // OPERANDS: none
     // DESCRIPTION: pops the top two stack values, compares using the
-    // greater than or equal to (>=) operator.
-    // STACK RESULT: push the constant value 1 onto the stack if the result
-    // of the operation is true or the constant value 0 if the result of the
-    // operation is false.
+    // greater than or equal to (>=) operator. STACK RESULT: push the
+    // constant value 1 onto the stack if the result of the operation is
+    // true or the constant value 0 if the result of the operation is
+    // false.
     //----------------------------------------------------------------------
     case DW_OP_ge:
       if (stack.size() < 2) {
@@ -2236,10 +2227,9 @@
     // OPCODE: DW_OP_gt
     // OPERANDS: none
     // DESCRIPTION: pops the top two stack values, compares using the
-    // greater than (>) operator.
-    // STACK RESULT: push the constant value 1 onto the stack if the result
-    // of the operation is true or the constant value 0 if the result of the
-    // operation is false.
+    // greater than (>) operator. STACK RESULT: push the constant value 1
+    // onto the stack if the result of the operation is true or the
+    // constant value 0 if the result of the operation is false.
     //----------------------------------------------------------------------
     case DW_OP_gt:
       if (stack.size() < 2) {
@@ -2258,11 +2248,10 @@
     //----------------------------------------------------------------------
     // OPCODE: DW_OP_le
     // OPERANDS: none
-    // DESCRIPTION: pops the top two stack values, compares using the
-    // less than or equal to (<=) operator.
-    // STACK RESULT: push the constant value 1 onto the stack if the result
-    // of the operation is true or the constant value 0 if the result of the
-    // operation is false.
+    // DESCRIPTION: pops the top two stack values, compares using the less
+    // than or equal to (<=) operator. STACK RESULT: push the constant
+    // value 1 onto the stack if the result of the operation is true or
+    // the constant value 0 if the result of the operation is false.
     //----------------------------------------------------------------------
     case DW_OP_le:
       if (stack.size() < 2) {
@@ -2281,11 +2270,10 @@
     //----------------------------------------------------------------------
     // OPCODE: DW_OP_lt
     // OPERANDS: none
-    // DESCRIPTION: pops the top two stack values, compares using the
-    // less than (<) operator.
-    // STACK RESULT: push the constant value 1 onto the stack if the result
-    // of the operation is true or the constant value 0 if the result of the
-    // operation is false.
+    // DESCRIPTION: pops the top two stack values, compares using the less
+    // than (<) operator. STACK RESULT: push the constant value 1 onto the
+    // stack if the result of the operation is true or the constant value
+    // 0 if the result of the operation is false.
     //----------------------------------------------------------------------
     case DW_OP_lt:
       if (stack.size() < 2) {
@@ -2304,11 +2292,10 @@
     //----------------------------------------------------------------------
     // OPCODE: DW_OP_ne
     // OPERANDS: none
-    // DESCRIPTION: pops the top two stack values, compares using the
-    // not equal (!=) operator.
-    // STACK RESULT: push the constant value 1 onto the stack if the result
-    // of the operation is true or the constant value 0 if the result of the
-    // operation is false.
+    // DESCRIPTION: pops the top two stack values, compares using the not
+    // equal (!=) operator. STACK RESULT: push the constant value 1 onto
+    // the stack if the result of the operation is true or the constant
+    // value 0 if the result of the operation is false.
     //----------------------------------------------------------------------
     case DW_OP_ne:
       if (stack.size() < 2) {
@@ -2428,8 +2415,8 @@
     // OPCODE: DW_OP_bregN
     // OPERANDS:
     //      SLEB128 offset from register N
-    // DESCRIPTION: Value is in memory at the address specified by register
-    // N plus an offset.
+    // DESCRIPTION: Value is in memory at the address specified by
+    // register N plus an offset.
     //----------------------------------------------------------------------
     case DW_OP_breg0:
     case DW_OP_breg1:
@@ -2480,8 +2467,8 @@
     // OPERANDS: 2
     //      ULEB128 literal operand that encodes the register.
     //      SLEB128 offset from register N
-    // DESCRIPTION: Value is in memory at the address specified by register
-    // N plus an offset.
+    // DESCRIPTION: Value is in memory at the address specified by
+    // register N plus an offset.
     //----------------------------------------------------------------------
     case DW_OP_bregx: {
       reg_num = opcodes.GetULEB128(&offset);
@@ -2536,14 +2523,14 @@
     // OPCODE: DW_OP_piece
     // OPERANDS: 1
     //      ULEB128: byte size of the piece
-    // DESCRIPTION: The operand describes the size in bytes of the piece of
-    // the object referenced by the DWARF expression whose result is at the
-    // top of the stack. If the piece is located in a register, but does not
-    // occupy the entire register, the placement of the piece within that
-    // register is defined by the ABI.
+    // DESCRIPTION: The operand describes the size in bytes of the piece
+    // of the object referenced by the DWARF expression whose result is at
+    // the top of the stack. If the piece is located in a register, but
+    // does not occupy the entire register, the placement of the piece
+    // within that register is defined by the ABI.
     //
-    // Many compilers store a single variable in sets of registers, or store
-    // a variable partially in memory and partially in registers.
+    // Many compilers store a single variable in sets of registers, or
+    // store a variable partially in memory and partially in registers.
     // DW_OP_piece provides a way of describing how large a part of a
     // variable a particular DWARF expression refers to.
     //----------------------------------------------------------------------
@@ -2554,9 +2541,9 @@
         Value curr_piece;
 
         if (stack.empty()) {
-          // In a multi-piece expression, this means that the current piece is
-          // not available.
-          // Fill with zeros for now by resizing the data and appending it
+          // In a multi-piece expression, this means that the current
+          // piece is not available. Fill with zeros for now by resizing
+          // the data and appending it
           curr_piece.ResizeData(piece_byte_size);
           ::memset(curr_piece.GetBuffer().GetBytes(), 0, piece_byte_size);
           pieces.AppendDataToHostBuffer(curr_piece);
@@ -2646,17 +2633,17 @@
 
           // Check if this is the first piece?
           if (op_piece_offset == 0) {
-            // This is the first piece, we should push it back onto the stack so
-            // subsequent
-            // pieces will be able to access this piece and add to it
+            // This is the first piece, we should push it back onto the
+            // stack so subsequent pieces will be able to access this
+            // piece and add to it
             if (pieces.AppendDataToHostBuffer(curr_piece) == 0) {
               if (error_ptr)
                 error_ptr->SetErrorString("failed to append piece data");
               return false;
             }
           } else {
-            // If this is the second or later piece there should be a value on
-            // the stack
+            // If this is the second or later piece there should be a
+            // value on the stack
             if (pieces.GetBuffer().GetByteSize() != op_piece_offset) {
               if (error_ptr)
                 error_ptr->SetErrorStringWithFormat(
@@ -2729,9 +2716,9 @@
     // DESCRIPTION: Pushes the address of the object currently being
     // evaluated as part of evaluation of a user presented expression.
     // This object may correspond to an independent variable described by
-    // its own DIE or it may be a component of an array, structure, or class
-    // whose address has been dynamically determined by an earlier step
-    // during user expression evaluation.
+    // its own DIE or it may be a component of an array, structure, or
+    // class whose address has been dynamically determined by an earlier
+    // step during user expression evaluation.
     //----------------------------------------------------------------------
     case DW_OP_push_object_address:
       if (object_address_ptr)
@@ -2748,22 +2735,22 @@
     // OPCODE: DW_OP_call2
     // OPERANDS:
     //      uint16_t compile unit relative offset of a DIE
-    // DESCRIPTION: Performs subroutine calls during evaluation
-    // of a DWARF expression. The operand is the 2-byte unsigned offset
-    // of a debugging information entry in the current compilation unit.
+    // DESCRIPTION: Performs subroutine calls during evaluation of a DWARF
+    // expression. The operand is the 2-byte unsigned offset of a
+    // debugging information entry in the current compilation unit.
     //
     // Operand interpretation is exactly like that for DW_FORM_ref2.
     //
-    // This operation transfers control of DWARF expression evaluation
-    // to the DW_AT_location attribute of the referenced DIE. If there is
-    // no such attribute, then there is no effect. Execution of the DWARF
-    // expression of a DW_AT_location attribute may add to and/or remove from
-    // values on the stack. Execution returns to the point following the call
-    // when the end of the attribute is reached. Values on the stack at the
-    // time of the call may be used as parameters by the called expression
-    // and values left on the stack by the called expression may be used as
-    // return values by prior agreement between the calling and called
-    // expressions.
+    // This operation transfers control of DWARF expression evaluation to
+    // the DW_AT_location attribute of the referenced DIE. If there is no
+    // such attribute, then there is no effect. Execution of the DWARF
+    // expression of a DW_AT_location attribute may add to and/or remove
+    // from values on the stack. Execution returns to the point following
+    // the call when the end of the attribute is reached. Values on the
+    // stack at the time of the call may be used as parameters by the
+    // called expression and values left on the stack by the called
+    // expression may be used as return values by prior agreement between
+    // the calling and called expressions.
     //----------------------------------------------------------------------
     case DW_OP_call2:
       if (error_ptr)
@@ -2773,23 +2760,24 @@
     // OPCODE: DW_OP_call4
     // OPERANDS: 1
     //      uint32_t compile unit relative offset of a DIE
-    // DESCRIPTION: Performs a subroutine call during evaluation of a DWARF
-    // expression. For DW_OP_call4, the operand is a 4-byte unsigned offset
-    // of a debugging information entry in  the current compilation unit.
+    // DESCRIPTION: Performs a subroutine call during evaluation of a
+    // DWARF expression. For DW_OP_call4, the operand is a 4-byte unsigned
+    // offset of a debugging information entry in  the current compilation
+    // unit.
     //
     // Operand interpretation DW_OP_call4 is exactly like that for
     // DW_FORM_ref4.
     //
-    // This operation transfers control of DWARF expression evaluation
-    // to the DW_AT_location attribute of the referenced DIE. If there is
-    // no such attribute, then there is no effect. Execution of the DWARF
-    // expression of a DW_AT_location attribute may add to and/or remove from
-    // values on the stack. Execution returns to the point following the call
-    // when the end of the attribute is reached. Values on the stack at the
-    // time of the call may be used as parameters by the called expression
-    // and values left on the stack by the called expression may be used as
-    // return values by prior agreement between the calling and called
-    // expressions.
+    // This operation transfers control of DWARF expression evaluation to
+    // the DW_AT_location attribute of the referenced DIE. If there is no
+    // such attribute, then there is no effect. Execution of the DWARF
+    // expression of a DW_AT_location attribute may add to and/or remove
+    // from values on the stack. Execution returns to the point following
+    // the call when the end of the attribute is reached. Values on the
+    // stack at the time of the call may be used as parameters by the
+    // called expression and values left on the stack by the called
+    // expression may be used as return values by prior agreement between
+    // the calling and called expressions.
     //----------------------------------------------------------------------
     case DW_OP_call4:
       if (error_ptr)
@@ -2812,13 +2800,14 @@
     // OPCODE: DW_OP_call_frame_cfa
     // OPERANDS: None
     // DESCRIPTION: Specifies a DWARF expression that pushes the value of
-    // the canonical frame address consistent with the call frame information
-    // located in .debug_frame (or in the FDEs of the eh_frame section).
+    // the canonical frame address consistent with the call frame
+    // information located in .debug_frame (or in the FDEs of the eh_frame
+    // section).
     //----------------------------------------------------------------------
     case DW_OP_call_frame_cfa:
       if (frame) {
-        // Note that we don't have to parse FDEs because this DWARF expression
-        // is commonly evaluated with a valid stack frame.
+        // Note that we don't have to parse FDEs because this DWARF
+        // expression is commonly evaluated with a valid stack frame.
         StackID id = frame->GetStackID();
         addr_t cfa = id.GetCallFrameAddress();
         if (cfa != LLDB_INVALID_ADDRESS) {
@@ -2837,12 +2826,11 @@
       break;
 
     //----------------------------------------------------------------------
-    // OPCODE: DW_OP_form_tls_address (or the old pre-DWARFv3 vendor extension
-    // opcode, DW_OP_GNU_push_tls_address)
-    // OPERANDS: none
-    // DESCRIPTION: Pops a TLS offset from the stack, converts it to
-    // an address in the current thread's thread-local storage block,
-    // and pushes it on the stack.
+    // OPCODE: DW_OP_form_tls_address (or the old pre-DWARFv3 vendor
+    // extension opcode, DW_OP_GNU_push_tls_address) OPERANDS: none
+    // DESCRIPTION: Pops a TLS offset from the stack, converts it to an
+    // address in the current thread's thread-local storage block, and
+    // pushes it on the stack.
     //----------------------------------------------------------------------
     case DW_OP_form_tls_address:
     case DW_OP_GNU_push_tls_address: {
@@ -2918,10 +2906,10 @@
     // OPCODE: DW_OP_GNU_const_index
     // OPERANDS: 1
     //      ULEB128: index to the .debug_addr section
-    // DESCRIPTION: Pushes an constant with the size of a machine address to
-    // the stack from the .debug_addr section with the base address specified
-    // by the DW_AT_addr_base attribute and the 0 based index is the ULEB128
-    // encoded index.
+    // DESCRIPTION: Pushes an constant with the size of a machine address
+    // to the stack from the .debug_addr section with the base address
+    // specified by the DW_AT_addr_base attribute and the 0 based index is
+    // the ULEB128 encoded index.
     //----------------------------------------------------------------------
     case DW_OP_GNU_const_index: {
       if (!dwarf_cu) {
@@ -2958,8 +2946,8 @@
   }
 
   if (stack.empty()) {
-    // Nothing on the stack, check if we created a piece value from DW_OP_piece
-    // or DW_OP_bit_piece opcodes
+    // Nothing on the stack, check if we created a piece value from
+    // DW_OP_piece or DW_OP_bit_piece opcodes
     if (pieces.GetBuffer().GetByteSize()) {
       result = pieces;
     } else {
Index: source/Expression/DiagnosticManager.cpp
===================================================================
--- source/Expression/DiagnosticManager.cpp
+++ source/Expression/DiagnosticManager.cpp
@@ -22,9 +22,8 @@
 
   std::string str = GetString();
 
-  // GetString() puts a separator after each diagnostic.
-  // We want to remove the last '\n' because log->PutCString will add one for
-  // us.
+  // GetString() puts a separator after each diagnostic. We want to remove
+  // the last '\n' because log->PutCString will add one for us.
 
   if (str.size() && str.back() == '\n') {
     str.pop_back();
Index: source/Expression/ExpressionSourceCode.cpp
===================================================================
--- source/Expression/ExpressionSourceCode.cpp
+++ source/Expression/ExpressionSourceCode.cpp
@@ -93,15 +93,15 @@
       m_state = CURRENT_FILE_POPPED;
   }
 
-  // An entry is valid if it occurs before the current line in
-  // the current file.
+  // An entry is valid if it occurs before the current line in the current
+  // file.
   bool IsValidEntry(uint32_t line) {
     switch (m_state) {
     case CURRENT_FILE_NOT_YET_PUSHED:
       return true;
     case CURRENT_FILE_PUSHED:
-      // If we are in file included in the current file,
-      // the entry should be added.
+      // If we are in file included in the current file, the entry should
+      // be added.
       if (m_file_stack.back() != m_current_file)
         return true;
 
@@ -281,8 +281,8 @@
                        debug_macros_stream.GetData(), g_expression_prefix,
                        target_specific_defines, m_prefix.c_str());
 
-    // First construct a tagged form of the user expression so we can find it
-    // later:
+    // First construct a tagged form of the user expression so we can find
+    // it later:
     std::string tagged_body;
     switch (wrapping_language) {
     default:
Index: source/Expression/ExpressionVariable.cpp
===================================================================
--- source/Expression/ExpressionVariable.cpp
+++ source/Expression/ExpressionVariable.cpp
@@ -69,9 +69,9 @@
   for (const IRExecutionUnit::JittedGlobalVariable &global_var :
        execution_unit_sp->GetJittedGlobalVariables()) {
     if (global_var.m_remote_addr != LLDB_INVALID_ADDRESS) {
-      // Demangle the name before inserting it, so that lookups by the ConstStr
-      // of the demangled name
-      // will find the mangled one (needed for looking up metadata pointers.)
+      // Demangle the name before inserting it, so that lookups by the
+      // ConstStr of the demangled name will find the mangled one (needed
+      // for looking up metadata pointers.)
       Mangled mangler(global_var.m_name);
       mangler.GetDemangledName(lldb::eLanguageTypeUnknown);
       m_symbol_map[global_var.m_name.GetCString()] = global_var.m_remote_addr;
Index: source/Expression/FunctionCaller.cpp
===================================================================
--- source/Expression/FunctionCaller.cpp
+++ source/Expression/FunctionCaller.cpp
@@ -120,8 +120,8 @@
                                 diagnostic_manager);
 }
 
-// FIXME: Assure that the ValueList we were passed in is consistent with the one
-// that defined this function.
+// FIXME: Assure that the ValueList we were passed in is consistent with
+// the one that defined this function.
 
 bool FunctionCaller::WriteFunctionArguments(
     ExecutionContext &exe_ctx, lldb::addr_t &args_addr_ref,
@@ -191,8 +191,8 @@
 
     // FIXME: For now just do scalars:
 
-    // Special case: if it's a pointer, don't do anything (the ABI supports
-    // passing cstrings)
+    // Special case: if it's a pointer, don't do anything (the ABI
+    // supports passing cstrings)
 
     if (arg_value->GetValueType() == Value::eValueTypeHostAddress &&
         arg_value->GetContextType() == Value::eContextTypeInvalid &&
@@ -264,12 +264,11 @@
 bool FunctionCaller::FetchFunctionResults(ExecutionContext &exe_ctx,
                                           lldb::addr_t args_addr,
                                           Value &ret_value) {
-  // Read the return value - it is the last field in the struct:
-  // FIXME: How does clang tell us there's no return value?  We need to handle
-  // that case.
-  // FIXME: Create our ThreadPlanCallFunction with the return CompilerType, and
-  // then use GetReturnValueObject
-  // to fetch the value.  That way we can fetch any values we need.
+  // Read the return value - it is the last field in the struct: FIXME:
+  // How does clang tell us there's no return value?  We need to handle
+  // that case. FIXME: Create our ThreadPlanCallFunction with the return
+  // CompilerType, and then use GetReturnValueObject to fetch the value.
+  // That way we can fetch any values we need.
 
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS |
                                                   LIBLLDB_LOG_STEP));
@@ -318,9 +317,9 @@
     DiagnosticManager &diagnostic_manager, Value &results) {
   lldb::ExpressionResults return_value = lldb::eExpressionSetupError;
 
-  // FunctionCaller::ExecuteFunction execution is always just to get the result.
-  // Do make sure we ignore
-  // breakpoints, unwind on error, and don't try to debug it.
+  // FunctionCaller::ExecuteFunction execution is always just to get the
+  // result. Do make sure we ignore breakpoints, unwind on error, and
+  // don't try to debug it.
   EvaluateExpressionOptions real_options = options;
   real_options.SetDebug(false);
   real_options.SetUnwindOnError(true);
@@ -354,10 +353,9 @@
   if (!call_plan_sp)
     return lldb::eExpressionSetupError;
 
-  // We need to make sure we record the fact that we are running an expression
-  // here
-  // otherwise this fact will fail to be recorded when fetching an Objective-C
-  // object description
+  // We need to make sure we record the fact that we are running an
+  // expression here otherwise this fact will fail to be recorded when
+  // fetching an Objective-C object description
   if (exe_ctx.GetProcessPtr())
     exe_ctx.GetProcessPtr()->SetRunningUserExpression(true);
 
Index: source/Expression/IRDynamicChecks.cpp
===================================================================
--- source/Expression/IRDynamicChecks.cpp
+++ source/Expression/IRDynamicChecks.cpp
@@ -82,9 +82,8 @@
 
 bool DynamicCheckerFunctions::DoCheckersExplainStop(lldb::addr_t addr,
                                                     Stream &message) {
-  // FIXME: We have to get the checkers to know why they scotched the call in
-  // more detail,
-  // so we can print a better message here.
+  // FIXME: We have to get the checkers to know why they scotched the call
+  // in more detail, so we can print a better message here.
   if (m_valid_pointer_check && m_valid_pointer_check->ContainsAddress(addr)) {
     message.Printf("Attempted to dereference an invalid pointer.");
     return true;
Index: source/Expression/IRExecutionUnit.cpp
===================================================================
--- source/Expression/IRExecutionUnit.cpp
+++ source/Expression/IRExecutionUnit.cpp
@@ -316,8 +316,8 @@
 
     std::unique_ptr<llvm::MemoryBuffer>
     getObject(const llvm::Module *module) override {
-      // Return nothing - we're just abusing the object-cache mechanism to dump
-      // objects.
+      // Return nothing - we're just abusing the object-cache mechanism to
+      // dump objects.
       return nullptr;
     }
   };
@@ -361,13 +361,11 @@
   CommitAllocations(process_sp);
   ReportAllocations(*m_execution_engine_ap);
 
-  // We have to do this after calling ReportAllocations because for the MCJIT,
-  // getGlobalValueAddress
-  // will cause the JIT to perform all relocations.  That can only be done once,
-  // and has to happen
-  // after we do the remapping from local -> remote.
-  // That means we don't know the local address of the Variables, but we don't
-  // need that for anything,
+  // We have to do this after calling ReportAllocations because for the
+  // MCJIT, getGlobalValueAddress will cause the JIT to perform all
+  // relocations.  That can only be done once, and has to happen after we
+  // do the remapping from local -> remote. That means we don't know the
+  // local address of the Variables, but we don't need that for anything,
   // so that's okay.
 
   std::function<void(llvm::GlobalValue &)> RegisterOneValue = [this](
@@ -378,9 +376,10 @@
 
       lldb::addr_t remote_addr = GetRemoteAddressForLocal(var_ptr_addr);
 
-      // This is a really unfortunae API that sometimes returns local addresses
-      // and sometimes returns remote addresses, based on whether
-      // the variable was relocated during ReportAllocations or not.
+      // This is a really unfortunae API that sometimes returns local
+      // addresses and sometimes returns remote addresses, based on
+      // whether the variable was relocated during ReportAllocations or
+      // not.
 
       if (remote_addr == LLDB_INVALID_ADDRESS) {
         remote_addr = var_ptr_addr;
@@ -755,8 +754,8 @@
 void IRExecutionUnit::CollectFallbackNames(
     std::vector<SearchSpec> &fallback_specs,
     const std::vector<SearchSpec> &C_specs) {
-  // As a last-ditch fallback, try the base name for C++ names.  It's terrible,
-  // but the DWARF doesn't always encode "extern C" correctly.
+  // As a last-ditch fallback, try the base name for C++ names.  It's
+  // terrible, but the DWARF doesn't always encode "extern C" correctly.
 
   for (const SearchSpec &C_spec : C_specs) {
     const ConstString &name = C_spec.name;
@@ -882,8 +881,8 @@
     if (get_external_load_address(load_address, sc_list, sc)) {
       return load_address;
     }
-    // if there are any searches we try after this, add an sc_list.Clear() in an
-    // "else" clause here
+    // if there are any searches we try after this, add an sc_list.Clear()
+    // in an "else" clause here
 
     if (best_internal_load_address != LLDB_INVALID_ADDRESS) {
       return best_internal_load_address;
Index: source/Expression/IRInterpreter.cpp
===================================================================
--- source/Expression/IRInterpreter.cpp
+++ source/Expression/IRInterpreter.cpp
@@ -443,8 +443,8 @@
     "Interpreter doesn't handle one of the expression's opcodes";
 static const char *unsupported_operand_error =
     "Interpreter doesn't handle one of the expression's operands";
-// static const char *interpreter_initialization_error = "Interpreter couldn't
-// be initialized";
+// static const char *interpreter_initialization_error = "Interpreter
+// couldn't be initialized";
 static const char *interpreter_internal_error =
     "Interpreter encountered an internal error";
 static const char *bad_value_error =
@@ -454,8 +454,8 @@
 static const char *memory_write_error = "Interpreter couldn't write to memory";
 static const char *memory_read_error = "Interpreter couldn't read from memory";
 static const char *infinite_loop_error = "Interpreter ran for too many cycles";
-// static const char *bad_result_error                 = "Result of expression
-// is in bad memory";
+// static const char *bad_result_error                 = "Result of
+// expression is in bad memory";
 static const char *too_many_functions_error =
     "Interpreter doesn't handle modules with multiple function bodies.";
 
@@ -1559,7 +1559,8 @@
       // Find number of arguments
       const int numArgs = call_inst->getNumArgOperands();
 
-      // We work with a fixed array of 16 arguments which is our upper limit
+      // We work with a fixed array of 16 arguments which is our upper
+      // limit
       static lldb_private::ABI::CallArgument rawArgs[16];
       if (numArgs >= 16) {
         error.SetErrorToGenericError();
@@ -1567,8 +1568,8 @@
         return false;
       }
 
-      // Push all function arguments to the argument list that will
-      // be passed to the call function thread plan
+      // Push all function arguments to the argument list that will be
+      // passed to the call function thread plan
       for (int i = 0; i < numArgs; i++) {
         // Get details of this argument
         llvm::Value *arg_op = call_inst->getArgOperand(i);
Index: source/Expression/IRMemoryMap.cpp
===================================================================
--- source/Expression/IRMemoryMap.cpp
+++ source/Expression/IRMemoryMap.cpp
@@ -47,14 +47,14 @@
   // The FindSpace algorithm's job is to find a region of memory that the
   // underlying process is unlikely to be using.
   //
-  // The memory returned by this function will never be written to.  The only
-  // point is that it should not shadow process memory if possible, so that
-  // expressions processing real values from the process do not use the
-  // wrong data.
+  // The memory returned by this function will never be written to.  The
+  // only point is that it should not shadow process memory if possible,
+  // so that expressions processing real values from the process do not
+  // use the wrong data.
   //
-  // If the process can in fact allocate memory (CanJIT() lets us know this)
-  // then this can be accomplished just be allocating memory in the inferior.
-  // Then no guessing is required.
+  // If the process can in fact allocate memory (CanJIT() lets us know
+  // this) then this can be accomplished just be allocating memory in the
+  // inferior. Then no guessing is required.
 
   lldb::TargetSP target_sp = m_target_wp.lock();
   lldb::ProcessSP process_sp = m_process_wp.lock();
@@ -80,8 +80,8 @@
 
   // At this point we know that we need to hunt.
   //
-  // First, go to the end of the existing allocations we've made if there are
-  // any allocations.  Otherwise start at the beginning of memory.
+  // First, go to the end of the existing allocations we've made if there
+  // are any allocations.  Otherwise start at the beginning of memory.
 
   if (m_allocations.empty()) {
     ret = 0x0;
@@ -92,9 +92,9 @@
     ret = llvm::alignTo(addr + alloc_size, 4096);
   }
 
-  // Now, if it's possible to use the GetMemoryRegionInfo API to detect mapped
-  // regions, walk forward through memory until a region is found that
-  // has adequate space for our allocation.
+  // Now, if it's possible to use the GetMemoryRegionInfo API to detect
+  // mapped regions, walk forward through memory until a region is found
+  // that has adequate space for our allocation.
   if (process_is_alive) {
     const uint64_t end_of_memory = process_sp->GetAddressByteSize() == 8
                                        ? 0xffffffffffffffffull
@@ -134,9 +134,9 @@
     }
   }
 
-  // We've tried our algorithm, and it didn't work.  Now we have to reset back
-  // to the end of the allocations we've already reported, or use a 'sensible'
-  // default if this is our first allocation.
+  // We've tried our algorithm, and it didn't work.  Now we have to reset
+  // back to the end of the allocations we've already reported, or use a
+  // 'sensible' default if this is our first allocation.
 
   if (m_allocations.empty()) {
     uint32_t address_byte_size = GetAddressByteSize();
@@ -187,17 +187,13 @@
 
   AllocationMap::const_iterator iter = m_allocations.lower_bound(addr);
 
-  // Since we only know that the returned interval begins at a location greater
-  // than or
-  // equal to where the given interval begins, it's possible that the given
-  // interval
-  // intersects either the returned interval or the previous interval.  Thus, we
-  // need to
-  // check both. Note that we only need to check these two intervals.  Since all
-  // intervals
+  // Since we only know that the returned interval begins at a location
+  // greater than or equal to where the given interval begins, it's
+  // possible that the given interval intersects either the returned
+  // interval or the previous interval.  Thus, we need to check both. Note
+  // that we only need to check these two intervals.  Since all intervals
   // are disjoint it is not possible that an adjacent interval does not
-  // intersect, but a
-  // non-adjacent interval does intersect.
+  // intersect, but a non-adjacent interval does intersect.
   if (iter != m_allocations.end()) {
     if (AllocationsIntersect(addr, size, iter->second.m_process_start,
                              iter->second.m_size))
@@ -216,17 +212,11 @@
 
 bool IRMemoryMap::AllocationsIntersect(lldb::addr_t addr1, size_t size1,
                                        lldb::addr_t addr2, size_t size2) {
-  // Given two half open intervals [A, B) and [X, Y), the only 6 permutations
-  // that satisfy
-  // A<B and X<Y are the following:
-  // A B X Y
-  // A X B Y  (intersects)
-  // A X Y B  (intersects)
-  // X A B Y  (intersects)
-  // X A Y B  (intersects)
-  // X Y A B
-  // The first is B <= X, and the last is Y <= A.
-  // So the condition is !(B <= X || Y <= A)), or (X < B && A < Y)
+  // Given two half open intervals [A, B) and [X, Y), the only 6
+  // permutations that satisfy A<B and X<Y are the following: A B X Y A X
+  // B Y  (intersects) A X Y B  (intersects) X A B Y  (intersects) X A Y B
+  // (intersects) X Y A B The first is B <= X, and the last is Y <= A. So
+  // the condition is !(B <= X || Y <= A)), or (X < B && A < Y)
   return (addr2 < (addr1 + size1)) && (addr1 < (addr2 + size2));
 }
 
Index: source/Expression/LLVMUserExpression.cpp
===================================================================
--- source/Expression/LLVMUserExpression.cpp
+++ source/Expression/LLVMUserExpression.cpp
@@ -74,9 +74,8 @@
                               lldb::UserExpressionSP &shared_ptr_to_me,
                               lldb::ExpressionVariableSP &result) {
   // The expression log is quite verbose, and if you're just tracking the
-  // execution of the
-  // expression, it's quite convenient to have these logs come out with the STEP
-  // log as well.
+  // execution of the expression, it's quite convenient to have these logs
+  // come out with the STEP log as well.
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS |
                                                   LIBLLDB_LOG_STEP));
 
Index: source/Expression/Materializer.cpp
===================================================================
--- source/Expression/Materializer.cpp
+++ source/Expression/Materializer.cpp
@@ -68,8 +68,8 @@
                            Materializer::PersistentVariableDelegate *delegate)
       : Entity(), m_persistent_variable_sp(persistent_variable_sp),
         m_delegate(delegate) {
-    // Hard-coding to maximum size of a pointer since persistent variables are
-    // materialized by reference
+    // Hard-coding to maximum size of a pointer since persistent variables
+    // are materialized by reference
     m_size = 8;
     m_alignment = 8;
   }
@@ -77,7 +77,8 @@
   void MakeAllocation(IRMemoryMap &map, Status &err) {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    // Allocate a spare memory area to store the persistent variable's contents.
+    // Allocate a spare memory area to store the persistent variable's
+    // contents.
 
     Status allocate_error;
     const bool zero_memory = false;
@@ -230,8 +231,8 @@
               ExpressionVariable::EVIsProgramReference &&
           !m_persistent_variable_sp->m_live_sp) {
         // If the reference comes from the program, then the
-        // ClangExpressionVariable's
-        // live variable data hasn't been set up yet.  Do this now.
+        // ClangExpressionVariable's live variable data hasn't been set up
+        // yet.  Do this now.
 
         lldb::addr_t location;
         Status read_error;
@@ -256,10 +257,8 @@
             frame_bottom != LLDB_INVALID_ADDRESS && location >= frame_bottom &&
             location <= frame_top) {
           // If the variable is resident in the stack frame created by the
-          // expression,
-          // then it cannot be relied upon to stay around.  We treat it as
-          // needing
-          // reallocation.
+          // expression, then it cannot be relied upon to stay around.  We
+          // treat it as needing reallocation.
           m_persistent_variable_sp->m_flags |=
               ExpressionVariable::EVIsLLDBAllocated;
           m_persistent_variable_sp->m_flags |=
@@ -330,8 +329,8 @@
     lldb::ProcessSP process_sp =
         map.GetBestExecutionContextScope()->CalculateProcess();
     if (!process_sp || !process_sp->CanJIT()) {
-      // Allocations are not persistent so persistent variables cannot stay
-      // materialized.
+      // Allocations are not persistent so persistent variables cannot
+      // stay materialized.
 
       m_persistent_variable_sp->m_flags |=
           ExpressionVariable::EVNeedsAllocation;
@@ -1269,8 +1268,8 @@
 
     if (!memcmp(register_data.GetDataStart(), m_register_contents->GetBytes(),
                 register_data.GetByteSize())) {
-      // No write required, and in particular we avoid errors if the register
-      // wasn't writable
+      // No write required, and in particular we avoid errors if the
+      // register wasn't writable
 
       m_register_contents.reset();
       return;
Index: source/Expression/REPL.cpp
===================================================================
--- source/Expression/REPL.cpp
+++ source/Expression/REPL.cpp
@@ -219,8 +219,8 @@
       // Strip the ':'
       code.erase(0, 1);
       if (Args::StripSpaces(code)) {
-        // "lldb" was followed by arguments, so just execute the command dump
-        // the results
+        // "lldb" was followed by arguments, so just execute the command
+        // dump the results
 
         // Turn off prompt on quit in case the user types ":quit"
         const bool saved_prompt_on_quit = ci.GetPromptOnQuit();
@@ -241,28 +241,28 @@
           io_handler.SetIsDone(true);
           if (debugger.CheckTopIOHandlerTypes(
                   IOHandler::Type::REPL, IOHandler::Type::CommandInterpreter)) {
-            // We typed "quit" or an alias to quit so we need to check if the
-            // command interpreter is above us and tell it that it is done as
-            // well
-            // so we don't drop back into the command interpreter if we have
-            // already
-            // quit
+            // We typed "quit" or an alias to quit so we need to check if
+            // the command interpreter is above us and tell it that it is
+            // done as well so we don't drop back into the command
+            // interpreter if we have already quit
             lldb::IOHandlerSP io_handler_sp(ci.GetIOHandler());
             if (io_handler_sp)
               io_handler_sp->SetIsDone(true);
           }
         }
       } else {
-        // ":" was followed by no arguments, so push the LLDB command prompt
+        // ":" was followed by no arguments, so push the LLDB command
+        // prompt
         if (debugger.CheckTopIOHandlerTypes(
                 IOHandler::Type::REPL, IOHandler::Type::CommandInterpreter)) {
-          // If the user wants to get back to the command interpreter and the
-          // command interpreter is what launched the REPL, then just let the
-          // REPL exit and fall back to the command interpreter.
+          // If the user wants to get back to the command interpreter and
+          // the command interpreter is what launched the REPL, then just
+          // let the REPL exit and fall back to the command interpreter.
           io_handler.SetIsDone(true);
         } else {
-          // The REPL wasn't launched the by the command interpreter, it is the
-          // base IOHandler, so we need to get the command interpreter and
+          // The REPL wasn't launched the by the command interpreter, it
+          // is the base IOHandler, so we need to get the command
+          // interpreter and
           lldb::IOHandlerSP io_handler_sp(ci.GetIOHandler());
           if (io_handler_sp) {
             io_handler_sp->SetIsDone(false);
@@ -444,8 +444,8 @@
       }
     }
 
-    // Don't complain about the REPL process going away if we are in the process
-    // of quitting.
+    // Don't complain about the REPL process going away if we are in the
+    // process of quitting.
     if (!did_quit && (!process_sp || !process_sp->IsAlive())) {
       error_sp->Printf(
           "error: REPL process is no longer alive, exiting REPL\n");
@@ -543,13 +543,11 @@
   debugger.PushIOHandler(io_handler_sp);
 
   // Check if we are in dedicated REPL mode where LLDB was start with the
-  // "--repl" option
-  // from the command line. Currently we know this by checking if the debugger
-  // already
-  // has a IOHandler thread.
+  // "--repl" option from the command line. Currently we know this by
+  // checking if the debugger already has a IOHandler thread.
   if (!debugger.HasIOHandlerThread()) {
-    // The debugger doesn't have an existing IOHandler thread, so this must be
-    // dedicated REPL mode...
+    // The debugger doesn't have an existing IOHandler thread, so this
+    // must be dedicated REPL mode...
     m_dedicated_repl_mode = true;
     debugger.StartIOHandlerThread();
     llvm::StringRef command_name_str("quit");
@@ -572,8 +570,8 @@
     if (process_sp && process_sp->IsAlive())
       process_sp->Destroy(false);
 
-    // Wait for the IO handler thread to exit (TODO: don't do this if the IO
-    // handler thread already exists...)
+    // Wait for the IO handler thread to exit (TODO: don't do this if the
+    // IO handler thread already exists...)
     debugger.JoinIOHandlerThread();
   }
 
Index: source/Expression/UserExpression.cpp
===================================================================
--- source/Expression/UserExpression.cpp
+++ source/Expression/UserExpression.cpp
@@ -178,10 +178,9 @@
   if (process == NULL || !process->CanJIT())
     execution_policy = eExecutionPolicyNever;
 
-  // We need to set the expression execution thread here, turns out parse can
-  // call functions in the process of
-  // looking up symbols, which will escape the context set by exe_ctx passed to
-  // Execute.
+  // We need to set the expression execution thread here, turns out parse
+  // can call functions in the process of looking up symbols, which will
+  // escape the context set by exe_ctx passed to Execute.
   lldb::ThreadSP thread_sp = exe_ctx.GetThreadSP();
   ThreadList::ExpressionExecutionThreadPusher execution_thread_pusher(
       thread_sp);
@@ -198,9 +197,9 @@
   else
     full_prefix = option_prefix;
 
-  // If the language was not specified in the expression command,
-  // set it to the language in the target's properties if
-  // specified, else default to the langage for the frame.
+  // If the language was not specified in the expression command, set it
+  // to the language in the target's properties if specified, else default
+  // to the langage for the frame.
   if (language == lldb::eLanguageTypeUnknown) {
     if (target->GetLanguage() != lldb::eLanguageTypeUnknown)
       language = target->GetLanguage();
@@ -264,8 +263,8 @@
         diagnostic_manager.Clear();
         user_expression_sp = fixed_expression_sp;
       } else {
-        // If the fixed expression failed to parse, don't tell the user about,
-        // that won't help.
+        // If the fixed expression failed to parse, don't tell the user
+        // about, that won't help.
         fixed_expression->clear();
       }
     }
@@ -288,8 +287,8 @@
   }
 
   if (parse_success) {
-    // If a pointer to a lldb::ModuleSP was passed in, return the JIT'ed module
-    // if one was created
+    // If a pointer to a lldb::ModuleSP was passed in, return the JIT'ed
+    // module if one was created
     if (jit_module_sp_ptr)
       *jit_module_sp_ptr = user_expression_sp->GetJITModule();
 
Index: source/Expression/UtilityFunction.cpp
===================================================================
--- source/Expression/UtilityFunction.cpp
+++ source/Expression/UtilityFunction.cpp
@@ -60,8 +60,8 @@
   }
 }
 
-// FIXME: We should check that every time this is called it is called with the
-// same return type & arguments...
+// FIXME: We should check that every time this is called it is called with
+// the same return type & arguments...
 
 FunctionCaller *UtilityFunction::MakeFunctionCaller(
     const CompilerType &return_type, const ValueList &arg_value_list,
Index: source/Host/android/HostInfoAndroid.cpp
===================================================================
--- source/Host/android/HostInfoAndroid.cpp
+++ source/Host/android/HostInfoAndroid.cpp
@@ -78,12 +78,10 @@
 bool HostInfoAndroid::ComputeTempFileBaseDirectory(FileSpec &file_spec) {
   bool success = HostInfoLinux::ComputeTempFileBaseDirectory(file_spec);
 
-  // On Android, there is no path which is guaranteed to be writable. If the
-  // user has not
-  // provided a path via an environment variable, the generic algorithm will
-  // deduce /tmp, which
-  // is plain wrong. In that case we have an invalid directory, we substitute
-  // the path with
+  // On Android, there is no path which is guaranteed to be writable. If
+  // the user has not provided a path via an environment variable, the
+  // generic algorithm will deduce /tmp, which is plain wrong. In that
+  // case we have an invalid directory, we substitute the path with
   // /data/local/tmp, which is correct at least in some cases (i.e., when
   // running as shell user).
   if (!success || !file_spec.Exists())
Index: source/Host/android/LibcGlue.cpp
===================================================================
--- source/Host/android/LibcGlue.cpp
+++ source/Host/android/LibcGlue.cpp
@@ -7,7 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-// This files adds functions missing from libc on earlier versions of Android
+// This files adds functions missing from libc on earlier versions of
+// Android
 
 #include <android/api-level.h>
 
Index: source/Host/common/Editline.cpp
===================================================================
--- source/Host/common/Editline.cpp
+++ source/Host/common/Editline.cpp
@@ -28,13 +28,14 @@
 using namespace lldb_private;
 using namespace lldb_private::line_editor;
 
-// Workaround for what looks like an OS X-specific issue, but other platforms
-// may benefit from something similar if issues arise.  The libedit library
-// doesn't explicitly initialize the curses termcap library, which it gets away
-// with until TERM is set to VT100 where it stumbles over an implementation
-// assumption that may not exist on other platforms.  The setupterm() function
-// would normally require headers that don't work gracefully in this context, so
-// the function declaraction has been hoisted here.
+// Workaround for what looks like an OS X-specific issue, but other
+// platforms may benefit from something similar if issues arise.  The
+// libedit library doesn't explicitly initialize the curses termcap
+// library, which it gets away with until TERM is set to VT100 where it
+// stumbles over an implementation assumption that may not exist on other
+// platforms.  The setupterm() function would normally require headers
+// that don't work gracefully in this context, so the function
+// declaraction has been hoisted here.
 #if defined(__APPLE__)
 extern "C" {
 int setupterm(char *term, int fildes, int *errret);
@@ -42,13 +43,12 @@
 #define USE_SETUPTERM_WORKAROUND
 #endif
 
-// Editline uses careful cursor management to achieve the illusion of editing a
-// multi-line block of text
-// with a single line editor.  Preserving this illusion requires fairly careful
-// management of cursor
+// Editline uses careful cursor management to achieve the illusion of
+// editing a multi-line block of text with a single line editor.
+// Preserving this illusion requires fairly careful management of cursor
 // state.  Read and understand the relationship between DisplayInput(),
-// MoveCursor(), SetCurrentLine(),
-// and SaveEditedLine() before making changes.
+// MoveCursor(), SetCurrentLine(), and SaveEditedLine() before making
+// changes.
 
 #define ESCAPE "\x1b"
 #define ANSI_FAINT ESCAPE "[2m"
@@ -70,8 +70,7 @@
 #define EditLineStringFormatSpec "%s"
 
 // use #defines so wide version functions and structs will resolve to old
-// versions
-// for case of libedit not built with wide char support
+// versions for case of libedit not built with wide char support
 #define history_w history
 #define history_winit history_init
 #define history_wend history_end
@@ -142,12 +141,10 @@
 }
 
 bool IsInputPending(FILE *file) {
-  // FIXME: This will be broken on Windows if we ever re-enable Editline.  You
-  // can't use select
-  // on something that isn't a socket.  This will have to be re-written to not
-  // use a FILE*, but
-  // instead use some kind of yet-to-be-created abstraction that select-like
-  // functionality on
+  // FIXME: This will be broken on Windows if we ever re-enable Editline.
+  // You can't use select on something that isn't a socket.  This will
+  // have to be re-written to not use a FILE*, but instead use some kind
+  // of yet-to-be-created abstraction that select-like functionality on
   // non-socket objects.
   const int fd = fileno(file);
   SelectHelper select_helper;
@@ -160,13 +157,13 @@
 namespace line_editor {
 typedef std::weak_ptr<EditlineHistory> EditlineHistoryWP;
 
-// EditlineHistory objects are sometimes shared between multiple
-// Editline instances with the same program name.
+// EditlineHistory objects are sometimes shared between multiple Editline
+// instances with the same program name.
 
 class EditlineHistory {
 private:
-  // Use static GetHistory() function to get a EditlineHistorySP to one of these
-  // objects
+  // Use static GetHistory() function to get a EditlineHistorySP to one of
+  // these objects
   EditlineHistory(const std::string &prefix, uint32_t size, bool unique_entries)
       : m_history(NULL), m_event(), m_prefix(prefix), m_path() {
     m_history = history_winit();
@@ -436,11 +433,10 @@
     if (history_w(pHistory, &history_event, H_FIRST) == -1)
       return CC_ERROR;
 
-    // Save any edits to the "live" entry in case we return by moving forward in
-    // history
-    // (it would be more bash-like to save over any current entry, but libedit
-    // doesn't
-    // offer the ability to add entries anywhere except the end.)
+    // Save any edits to the "live" entry in case we return by moving
+    // forward in history (it would be more bash-like to save over any
+    // current entry, but libedit doesn't offer the ability to add entries
+    // anywhere except the end.)
     SaveEditedLine();
     m_live_history_lines = m_input_lines;
     m_in_history = true;
@@ -465,9 +461,8 @@
   m_input_lines = new_input_lines;
   DisplayInput();
 
-  // Prepare to edit the last line when moving to previous entry, or the first
-  // line
-  // when moving to next entry
+  // Prepare to edit the last line when moving to previous entry, or the
+  // first line when moving to next entry
   SetCurrentLine(m_current_line_index =
                      earlier ? (int)m_input_lines.size() - 1 : 0);
   MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingPrompt);
@@ -477,8 +472,8 @@
 int Editline::GetCharacter(EditLineGetCharType *c) {
   const LineInfoW *info = el_wline(m_editline);
 
-  // Paint a faint version of the desired prompt over the version libedit draws
-  // (will only be requested if colors are supported)
+  // Paint a faint version of the desired prompt over the version libedit
+  // draws (will only be requested if colors are supported)
   if (m_needs_prompt_repaint) {
     MoveCursor(CursorLocation::EditingCursor, CursorLocation::EditingPrompt);
     fprintf(m_output_file, "%s"
@@ -490,8 +485,8 @@
   }
 
   if (m_multiline_enabled) {
-    // Detect when the number of rows used for this input line changes due to an
-    // edit
+    // Detect when the number of rows used for this input line changes due
+    // to an edit
     int lineLength = (int)((info->lastchar - info->buffer) + GetPromptWidth());
     int new_line_rows = (lineLength / m_terminal_width) + 1;
     if (m_current_line_rows != -1 && new_line_rows != m_current_line_rows) {
@@ -509,13 +504,11 @@
     lldb::ConnectionStatus status = lldb::eConnectionStatusSuccess;
     char ch = 0;
 
-    // This mutex is locked by our caller (GetLine). Unlock it while we read a
-    // character
-    // (blocking operation), so we do not hold the mutex indefinitely. This
-    // gives a chance
-    // for someone to interrupt us. After Read returns, immediately lock the
-    // mutex again and
-    // check if we were interrupted.
+    // This mutex is locked by our caller (GetLine). Unlock it while we
+    // read a character (blocking operation), so we do not hold the mutex
+    // indefinitely. This gives a chance for someone to interrupt us.
+    // After Read returns, immediately lock the mutex again and check if
+    // we were interrupted.
     m_output_mutex.unlock();
     int read_count = m_input_connection.Read(&ch, 1, llvm::None, status, NULL);
     m_output_mutex.lock();
@@ -558,7 +551,8 @@
 }
 
 unsigned char Editline::BreakLineCommand(int ch) {
-  // Preserve any content beyond the cursor, truncate and save the current line
+  // Preserve any content beyond the cursor, truncate and save the current
+  // line
   const LineInfoW *info = el_wline(m_editline);
   auto current_line =
       EditLineStringType(info->buffer, info->cursor - info->buffer);
@@ -570,8 +564,8 @@
   if (::IsOnlySpaces(new_line_fragment))
     new_line_fragment = EditLineConstString("");
 
-  // Establish the new cursor position at the start of a line when inserting a
-  // line break
+  // Establish the new cursor position at the start of a line when
+  // inserting a line break
   m_revert_cursor_index = 0;
 
   // Don't perform automatic formatting when pasting
@@ -592,21 +586,23 @@
     }
   }
 
-  // Insert the new line and repaint everything from the split line on down
+  // Insert the new line and repaint everything from the split line on
+  // down
   m_input_lines.insert(m_input_lines.begin() + m_current_line_index + 1,
                        new_line_fragment);
   MoveCursor(CursorLocation::EditingCursor, CursorLocation::EditingPrompt);
   DisplayInput(m_current_line_index);
 
-  // Reposition the cursor to the right line and prepare to edit the new line
+  // Reposition the cursor to the right line and prepare to edit the new
+  // line
   SetCurrentLine(m_current_line_index + 1);
   MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingPrompt);
   return CC_NEWLINE;
 }
 
 unsigned char Editline::EndOrAddLineCommand(int ch) {
-  // Don't perform end of input detection when pasting, always treat this as a
-  // line break
+  // Don't perform end of input detection when pasting, always treat this
+  // as a line break
   if (IsInputPending(m_input_file)) {
     return BreakLineCommand(ch);
   }
@@ -614,7 +610,8 @@
   // Save any edits to this line
   SaveEditedLine();
 
-  // If this is the end of the last line, consider whether to add a line instead
+  // If this is the end of the last line, consider whether to add a line
+  // instead
   const LineInfoW *info = el_wline(m_editline);
   if (m_current_line_index == m_input_lines.size() - 1 &&
       info->cursor == info->lastchar) {
@@ -625,7 +622,8 @@
         return BreakLineCommand(ch);
       }
 
-      // The completion test is allowed to change the input lines when complete
+      // The completion test is allowed to change the input lines when
+      // complete
       m_input_lines.clear();
       for (unsigned index = 0; index < lines.GetSize(); index++) {
 #if LLDB_EDITLINE_USE_WCHAR
@@ -667,7 +665,8 @@
   // Prepare to combine this line with the one below
   MoveCursor(CursorLocation::EditingCursor, CursorLocation::EditingPrompt);
 
-  // Insert the next line of text at the cursor and restore the cursor position
+  // Insert the next line of text at the cursor and restore the cursor
+  // position
   const EditLineCharType *cursor = info->cursor;
   el_winsertstr(m_editline, m_input_lines[m_current_line_index + 1].c_str());
   info->cursor = cursor;
@@ -685,7 +684,8 @@
 unsigned char Editline::DeletePreviousCharCommand(int ch) {
   LineInfoW *info = const_cast<LineInfoW *>(el_wline(m_editline));
 
-  // Just delete the previous character normally when not at the start of a line
+  // Just delete the previous character normally when not at the start of
+  // a line
   if (info->cursor > info->buffer) {
     el_deletestr(m_editline, 1);
     return CC_REFRESH;
@@ -708,9 +708,8 @@
           CountRowsForLine(priorLine), 1);
   DisplayInput(m_current_line_index);
 
-  // Put the cursor back where libedit expects it to be before returning to
-  // editing
-  // by telling libedit about the newly inserted text
+  // Put the cursor back where libedit expects it to be before returning
+  // to editing by telling libedit about the newly inserted text
   MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingPrompt);
   el_winsertstr(m_editline, priorLine.c_str());
   return CC_REDISPLAY;
@@ -743,8 +742,8 @@
 
   // Handle attempts to move down from the last line
   if (m_current_line_index == m_input_lines.size() - 1) {
-    // Don't add an extra line if the existing last line is blank, move through
-    // history instead
+    // Don't add an extra line if the existing last line is blank, move
+    // through history instead
     if (IsOnlySpaces()) {
       return RecallHistory(false);
     }
@@ -762,7 +761,8 @@
         EditLineStringType(indentation, EditLineCharType(' ')));
   }
 
-  // Move down past the current line using newlines to force scrolling if needed
+  // Move down past the current line using newlines to force scrolling if
+  // needed
   SetCurrentLine(m_current_line_index + 1);
   const LineInfoW *info = el_wline(m_editline);
   int cursor_position = (int)((info->cursor - info->buffer) + GetPromptWidth());
@@ -823,9 +823,8 @@
   MoveCursor(CursorLocation::EditingCursor, CursorLocation::EditingPrompt);
   DisplayInput(m_current_line_index);
 
-  // Reposition the cursor back on the original line and prepare to restart
-  // editing
-  // with a new cursor position
+  // Reposition the cursor back on the original line and prepare to
+  // restart editing with a new cursor position
   SetCurrentLine(m_current_line_index);
   MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingPrompt);
   m_revert_cursor_index = cursor_position + indent_correction;
@@ -946,8 +945,8 @@
 
   if (m_editline) {
     // Disable edit mode to stop the terminal from flushing all input
-    // during the call to el_end() since we expect to have multiple editline
-    // instances in this program.
+    // during the call to el_end() since we expect to have multiple
+    // editline instances in this program.
     el_set(m_editline, EL_EDITMODE, 0);
     el_end(m_editline);
   }
@@ -973,7 +972,8 @@
             return Editline::InstanceFor(editline)->GetCharacter(c);
           }));
 
-  // Commands used for multiline support, registered whether or not they're used
+  // Commands used for multiline support, registered whether or not
+  // they're used
   el_wset(m_editline, EL_ADDFN, EditLineConstString("lldb-break-line"),
           EditLineConstString("Insert a line break"),
           (EditlineCommandCallbackType)([](EditLine *editline, int ch) {
@@ -1031,13 +1031,11 @@
             return Editline::InstanceFor(editline)->FixIndentationCommand(ch);
           }));
 
-  // Register the complete callback under two names for compatibility with older
-  // clients using
-  // custom .editrc files (largely because libedit has a bad bug where if you
-  // have a bind command
-  // that tries to bind to a function name that doesn't exist, it can corrupt
-  // the heap and
-  // crash your process later.)
+  // Register the complete callback under two names for compatibility with
+  // older clients using custom .editrc files (largely because libedit has
+  // a bad bug where if you have a bind command that tries to bind to a
+  // function name that doesn't exist, it can corrupt the heap and crash
+  // your process later.)
   EditlineCommandCallbackType complete_callback = [](EditLine *editline,
                                                      int ch) {
     return Editline::InstanceFor(editline)->TabCommand(ch);
@@ -1118,8 +1116,7 @@
              NULL);
 
       // Escape is absorbed exiting edit mode, so re-register important
-      // sequences
-      // without the prefix
+      // sequences without the prefix
       el_set(m_editline, EL_BIND, "-a", "[A", "lldb-previous-line", NULL);
       el_set(m_editline, EL_BIND, "-a", "[B", "lldb-next-line", NULL);
       el_set(m_editline, EL_BIND, "-a", "[\\^", "lldb-revert-line", NULL);
@@ -1161,8 +1158,9 @@
                                                        // issues
       });
 
-      // We must make sure to initialize the terminal a given file descriptor
-      // only once. If we do this multiple times, we start leaking memory.
+      // We must make sure to initialize the terminal a given file
+      // descriptor only once. If we do this multiple times, we start
+      // leaking memory.
       std::lock_guard<std::mutex> guard(*g_init_terminal_fds_mutex_ptr);
       if (g_init_terminal_fds_ptr->find(term_fd) ==
           g_init_terminal_fds_ptr->end()) {
@@ -1177,17 +1175,17 @@
 Editline::~Editline() {
   if (m_editline) {
     // Disable edit mode to stop the terminal from flushing all input
-    // during the call to el_end() since we expect to have multiple editline
-    // instances in this program.
+    // during the call to el_end() since we expect to have multiple
+    // editline instances in this program.
     el_set(m_editline, EL_EDITMODE, 0);
     el_end(m_editline);
     m_editline = nullptr;
   }
 
   // EditlineHistory objects are sometimes shared between multiple
-  // Editline instances with the same program name. So just release
-  // our shared pointer and if we are the last owner, it will save the
-  // history to the history save file automatically.
+  // Editline instances with the same program name. So just release our
+  // shared pointer and if we are the last owner, it will save the history
+  // to the history save file automatically.
   m_history_sp.reset();
 }
 
@@ -1204,8 +1202,8 @@
   if (m_editline != nullptr) {
     el_resize(m_editline);
     int columns;
-    // Despite the man page claiming non-zero indicates success, it's actually
-    // zero
+    // Despite the man page claiming non-zero indicates success, it's
+    // actually zero
     if (el_get(m_editline, EL_GETTC, "co", &columns) == 0) {
       m_terminal_width = columns;
       if (m_current_line_rows != -1) {
@@ -1313,8 +1311,8 @@
                         bool &interrupted) {
   ConfigureEditor(true);
 
-  // Print the initial input lines, then move the cursor back up to the start of
-  // input
+  // Print the initial input lines, then move the cursor back up to the
+  // start of input
   SetBaseLineNumber(first_line_number);
   m_input_lines = std::vector<EditLineStringType>();
   m_input_lines.insert(m_input_lines.begin(), EditLineConstString(""));
Index: source/Host/common/File.cpp
===================================================================
--- source/Host/common/File.cpp
+++ source/Host/common/File.cpp
@@ -97,8 +97,8 @@
   if (DescriptorIsValid())
     return m_descriptor;
 
-  // Don't open the file descriptor if we don't need to, just get it from the
-  // stream if we have one.
+  // Don't open the file descriptor if we don't need to, just get it from
+  // the stream if we have one.
   if (StreamIsValid()) {
 #if defined(_WIN32)
     return _fileno(m_stream);
@@ -126,8 +126,8 @@
       const char *mode = GetStreamOpenModeFromOptions(m_options);
       if (mode) {
         if (!m_should_close_fd) {
-// We must duplicate the file descriptor if we don't own it because
-// when you call fdopen, the stream will own the fd
+// We must duplicate the file descriptor if we don't own it because when
+// you call fdopen, the stream will own the fd
 #ifdef _WIN32
           m_descriptor = ::_dup(GetDescriptor());
 #else
@@ -139,8 +139,8 @@
         m_stream =
             llvm::sys::RetryAfterSignal(nullptr, ::fdopen, m_descriptor, mode);
 
-        // If we got a stream, then we own the stream and should no
-        // longer own the descriptor because fclose() will close it for us
+        // If we got a stream, then we own the stream and should no longer
+        // own the descriptor because fclose() will close it for us
 
         if (m_stream) {
           m_own_stream = true;
Index: source/Host/common/Host.cpp
===================================================================
--- source/Host/common/Host.cpp
+++ source/Host/common/Host.cpp
@@ -119,9 +119,9 @@
 
 #ifndef __linux__
 //------------------------------------------------------------------
-// Scoped class that will disable thread canceling when it is
-// constructed, and exception safely restore the previous value it
-// when it goes out of scope.
+// Scoped class that will disable thread canceling when it is constructed,
+// and exception safely restore the previous value it when it goes out of
+// scope.
 //------------------------------------------------------------------
 class ScopedPThreadCancelDisabler {
 public:
@@ -332,8 +332,8 @@
     return "SIGABRT"; // 6    abort()
 #if defined(SIGPOLL)
 #if !defined(SIGIO) || (SIGPOLL != SIGIO)
-  // Under some GNU/Linux, SIGPOLL and SIGIO are the same. Causing the build to
-  // fail with 'multiple define cases with same value'
+  // Under some GNU/Linux, SIGPOLL and SIGIO are the same. Causing the
+  // build to fail with 'multiple define cases with same value'
   case SIGPOLL:
     return "SIGPOLL"; // 7    pollable event ([XSR] generated, not supported)
 #endif
@@ -544,7 +544,8 @@
     if (timed_out) {
       error.SetErrorString("timed out waiting for shell command to complete");
 
-      // Kill the process since it didn't complete within the timeout specified
+      // Kill the process since it didn't complete within the timeout
+      // specified
       Kill(pid, SIGKILL);
       // Wait for the monitor callback to get the message
       timed_out = false;
@@ -580,7 +581,8 @@
   return error;
 }
 
-// The functions below implement process launching for non-Apple-based platforms
+// The functions below implement process launching for non-Apple-based
+// platforms
 #if !defined(__APPLE__)
 Status Host::LaunchProcess(ProcessLaunchInfo &launch_info) {
   std::unique_ptr<ProcessLauncher> delegate_launcher;
@@ -594,9 +596,8 @@
   Status error;
   HostProcess process = launcher.LaunchProcess(launch_info, error);
 
-  // TODO(zturner): It would be better if the entire HostProcess were returned
-  // instead of writing
-  // it into this structure.
+  // TODO(zturner): It would be better if the entire HostProcess were
+  // returned instead of writing it into this structure.
   launch_info.SetProcessID(process.GetProcessId());
 
   return error;
Index: source/Host/common/HostInfoBase.cpp
===================================================================
--- source/Host/common/HostInfoBase.cpp
+++ source/Host/common/HostInfoBase.cpp
@@ -36,16 +36,16 @@
 // The HostInfoBaseFields is a work around for windows not supporting
 // static variables correctly in a thread safe way. Really each of the
 // variables in HostInfoBaseFields should live in the functions in which
-// they are used and each one should be static, but the work around is
-// in place to avoid this restriction. Ick.
+// they are used and each one should be static, but the work around is in
+// place to avoid this restriction. Ick.
 //----------------------------------------------------------------------
 
 struct HostInfoBaseFields {
   ~HostInfoBaseFields() {
     if (m_lldb_process_tmp_dir.Exists()) {
-      // Remove the LLDB temporary directory if we have one. Set "recurse" to
-      // true to all files that were created for the LLDB process can be cleaned
-      // up.
+      // Remove the LLDB temporary directory if we have one. Set "recurse"
+      // to true to all files that were created for the LLDB process can
+      // be cleaned up.
       llvm::sys::fs::remove_directories(m_lldb_process_tmp_dir.GetPath());
     }
   }
@@ -282,18 +282,20 @@
 
 bool HostInfoBase::ComputeSharedLibraryDirectory(FileSpec &file_spec) {
   // To get paths related to LLDB we get the path to the executable that
-  // contains this function. On MacOSX this will be "LLDB.framework/.../LLDB".
-  // On other posix systems, we will get .../lib(64|32)?/liblldb.so.
+  // contains this function. On MacOSX this will be
+  // "LLDB.framework/.../LLDB". On other posix systems, we will get
+  // .../lib(64|32)?/liblldb.so.
 
   FileSpec lldb_file_spec(
       Host::GetModuleFileSpecForHostAddress(reinterpret_cast<void *>(
           reinterpret_cast<intptr_t>(HostInfoBase::GetLLDBPath))));
 
-  // This is necessary because when running the testsuite the shlib might be a
-  // symbolic link inside the Python resource dir.
+  // This is necessary because when running the testsuite the shlib might
+  // be a symbolic link inside the Python resource dir.
   FileSystem::ResolveSymbolicLink(lldb_file_spec, lldb_file_spec);
 
-  // Remove the filename so that this FileSpec only represents the directory.
+  // Remove the filename so that this FileSpec only represents the
+  // directory.
   file_spec.GetDirectory() = lldb_file_spec.GetDirectory();
 
   return (bool)file_spec.GetDirectory();
@@ -346,16 +348,16 @@
 }
 
 bool HostInfoBase::ComputeSystemPluginsDirectory(FileSpec &file_spec) {
-  // TODO(zturner): Figure out how to compute the system plugins directory for
-  // all platforms.
+  // TODO(zturner): Figure out how to compute the system plugins directory
+  // for all platforms.
   return false;
 }
 
 bool HostInfoBase::ComputeClangDirectory(FileSpec &file_spec) { return false; }
 
 bool HostInfoBase::ComputeUserPluginsDirectory(FileSpec &file_spec) {
-  // TODO(zturner): Figure out how to compute the user plugins directory for all
-  // platforms.
+  // TODO(zturner): Figure out how to compute the user plugins directory
+  // for all platforms.
   return false;
 }
 
Index: source/Host/common/MainLoop.cpp
===================================================================
--- source/Host/common/MainLoop.cpp
+++ source/Host/common/MainLoop.cpp
@@ -19,10 +19,10 @@
 #include <time.h>
 #include <vector>
 
-// Multiplexing is implemented using kqueue on systems that support it (BSD
-// variants including OSX). On linux we use ppoll, while android uses pselect
-// (ppoll is present but not implemented properly). On windows we use WSApoll
-// (which does not support signals).
+// Multiplexing is implemented using kqueue on systems that support it
+// (BSD variants including OSX). On linux we use ppoll, while android uses
+// pselect (ppoll is present but not implemented properly). On windows we
+// use WSApoll (which does not support signals).
 
 #if HAVE_SYS_EVENT_H
 #include <sys/event.h>
@@ -155,10 +155,10 @@
 #ifdef __ANDROID__
 Status MainLoop::RunImpl::Poll() {
   // ppoll(2) is not supported on older all android versions. Also, older
-  // versions android (API <= 19) implemented pselect in a non-atomic way, as a
-  // combination of pthread_sigmask and select. This is not sufficient for us,
-  // as we rely on the atomicity to correctly implement signal polling, so we
-  // call the underlying syscall ourselves.
+  // versions android (API <= 19) implemented pselect in a non-atomic way,
+  // as a combination of pthread_sigmask and select. This is not
+  // sufficient for us, as we rely on the atomicity to correctly implement
+  // signal polling, so we call the underlying syscall ourselves.
 
   FD_ZERO(&read_fd_set);
   int nfds = 0;
@@ -209,8 +209,8 @@
 
 void MainLoop::RunImpl::ProcessEvents() {
 #ifdef __ANDROID__
-  // Collect first all readable file descriptors into a separate vector and then
-  // iterate over it to invoke callbacks. Iterating directly over
+  // Collect first all readable file descriptors into a separate vector
+  // and then iterate over it to invoke callbacks. Iterating directly over
   // loop.m_read_fds is not possible because the callbacks can modify the
   // container which could invalidate the iterator.
   std::vector<IOObject::WaitableHandle> fds;
@@ -284,9 +284,8 @@
   return CreateReadHandle(object_sp);
 }
 
-// We shall block the signal, then install the signal handler. The signal will
-// be unblocked in
-// the Run() function to check for signal delivery.
+// We shall block the signal, then install the signal handler. The signal
+// will be unblocked in the Run() function to check for signal delivery.
 MainLoop::SignalHandleUP
 MainLoop::RegisterSignal(int signo, const Callback &callback, Status &error) {
 #ifdef SIGNAL_POLLING_UNSUPPORTED
@@ -309,8 +308,8 @@
 
   g_signal_flags[signo] = 0;
 
-  // Even if using kqueue, the signal handler will still be invoked, so it's
-  // important to replace it with our "bening" handler.
+  // Even if using kqueue, the signal handler will still be invoked, so
+  // it's important to replace it with our "bening" handler.
   int ret = sigaction(signo, &new_action, &info.old_action);
   assert(ret == 0 && "sigaction failed");
 
@@ -321,9 +320,9 @@
   assert(ret == 0);
 #endif
 
-  // If we're using kqueue, the signal needs to be unblocked in order to recieve
-  // it. If using pselect/ppoll, we need to block it, and later unblock it as a
-  // part of the system call.
+  // If we're using kqueue, the signal needs to be unblocked in order to
+  // recieve it. If using pselect/ppoll, we need to block it, and later
+  // unblock it as a part of the system call.
   ret = pthread_sigmask(HAVE_SYS_EVENT_H ? SIG_UNBLOCK : SIG_BLOCK,
                         &new_action.sa_mask, &old_set);
   assert(ret == 0 && "pthread_sigmask failed");
Index: source/Host/common/NativeBreakpointList.cpp
===================================================================
--- source/Host/common/NativeBreakpointList.cpp
+++ source/Host/common/NativeBreakpointList.cpp
@@ -104,8 +104,8 @@
     return error;
   }
 
-  // Breakpoint has no more references.  Disable it if it's not
-  // already disabled.
+  // Breakpoint has no more references.  Disable it if it's not already
+  // disabled.
   if (log)
     log->Printf("NativeBreakpointList::%s addr = 0x%" PRIx64
                 " -- removing due to no remaining references",
@@ -123,7 +123,8 @@
         log->Printf("NativeBreakpointList::%s addr = 0x%" PRIx64
                     " -- removal FAILED: %s",
                     __FUNCTION__, addr, error.AsCString());
-      // Continue since we still want to take it out of the breakpoint list.
+      // Continue since we still want to take it out of the breakpoint
+      // list.
     }
   } else {
     if (log)
Index: source/Host/common/NativeProcessProtocol.cpp
===================================================================
--- source/Host/common/NativeProcessProtocol.cpp
+++ source/Host/common/NativeProcessProtocol.cpp
@@ -137,29 +137,29 @@
 Status NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size,
                                             uint32_t watch_flags,
                                             bool hardware) {
-  // This default implementation assumes setting the watchpoint for
-  // the process will require setting the watchpoint for each of the
-  // threads.  Furthermore, it will track watchpoints set for the
-  // process and will add them to each thread that is attached to
-  // via the (FIXME implement) OnThreadAttached () method.
+  // This default implementation assumes setting the watchpoint for the
+  // process will require setting the watchpoint for each of the threads.
+  // Furthermore, it will track watchpoints set for the process and will
+  // add them to each thread that is attached to via the (FIXME implement)
+  // OnThreadAttached () method.
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   // Update the thread list
   UpdateThreads();
 
-  // Keep track of the threads we successfully set the watchpoint
-  // for.  If one of the thread watchpoint setting operations fails,
-  // back off and remove the watchpoint for all the threads that
-  // were successfully set so we get back to a consistent state.
+  // Keep track of the threads we successfully set the watchpoint for.  If
+  // one of the thread watchpoint setting operations fails, back off and
+  // remove the watchpoint for all the threads that were successfully set
+  // so we get back to a consistent state.
   std::vector<NativeThreadProtocol *> watchpoint_established_threads;
 
-  // Tell each thread to set a watchpoint.  In the event that
-  // hardware watchpoints are requested but the SetWatchpoint fails,
-  // try to set a software watchpoint as a fallback.  It's
-  // conceivable that if there are more threads than hardware
-  // watchpoints available, some of the threads will fail to set
-  // hardware watchpoints while software ones may be available.
+  // Tell each thread to set a watchpoint.  In the event that hardware
+  // watchpoints are requested but the SetWatchpoint fails, try to set a
+  // software watchpoint as a fallback.  It's conceivable that if there
+  // are more threads than hardware watchpoints available, some of the
+  // threads will fail to set hardware watchpoints while software ones may
+  // be available.
   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
   for (const auto &thread : m_threads) {
     assert(thread && "thread list should not have a NULL thread!");
@@ -167,8 +167,8 @@
     Status thread_error =
         thread->SetWatchpoint(addr, size, watch_flags, hardware);
     if (thread_error.Fail() && hardware) {
-      // Try software watchpoints since we failed on hardware watchpoint setting
-      // and we may have just run out of hardware watchpoints.
+      // Try software watchpoints since we failed on hardware watchpoint
+      // setting and we may have just run out of hardware watchpoints.
       thread_error = thread->SetWatchpoint(addr, size, watch_flags, false);
       if (thread_error.Success())
         LLDB_LOG(log,
@@ -176,13 +176,13 @@
     }
 
     if (thread_error.Success()) {
-      // Remember that we set this watchpoint successfully in
-      // case we need to clear it later.
+      // Remember that we set this watchpoint successfully in case we need
+      // to clear it later.
       watchpoint_established_threads.push_back(thread.get());
     } else {
-      // Unset the watchpoint for each thread we successfully
-      // set so that we get back to a consistent state of "not
-      // set" for the watchpoint.
+      // Unset the watchpoint for each thread we successfully set so that
+      // we get back to a consistent state of "not set" for the
+      // watchpoint.
       for (auto unwatch_thread_sp : watchpoint_established_threads) {
         Status remove_error = unwatch_thread_sp->RemoveWatchpoint(addr);
         if (remove_error.Fail())
@@ -208,9 +208,9 @@
 
     const Status thread_error = thread->RemoveWatchpoint(addr);
     if (thread_error.Fail()) {
-      // Keep track of the first thread error if any threads
-      // fail. We want to try to remove the watchpoint from
-      // every thread, though, even if one or more have errors.
+      // Keep track of the first thread error if any threads fail. We want
+      // to try to remove the watchpoint from every thread, though, even
+      // if one or more have errors.
       if (!overall_error.Fail())
         overall_error = thread_error;
     }
@@ -234,33 +234,36 @@
   // Update the thread list
   UpdateThreads();
 
-  // Exit here if target does not have required hardware breakpoint capability.
+  // Exit here if target does not have required hardware breakpoint
+  // capability.
   auto hw_debug_cap = GetHardwareDebugSupportInfo();
 
   if (hw_debug_cap == llvm::None || hw_debug_cap->first == 0 ||
       hw_debug_cap->first <= m_hw_breakpoints_map.size())
     return Status("Target does not have required no of hardware breakpoints");
 
-  // Vector below stores all thread pointer for which we have we successfully
-  // set this hardware breakpoint. If any of the current process threads fails
-  // to set this hardware breakpoint then roll back and remove this breakpoint
-  // for all the threads that had already set it successfully.
+  // Vector below stores all thread pointer for which we have we
+  // successfully set this hardware breakpoint. If any of the current
+  // process threads fails to set this hardware breakpoint then roll back
+  // and remove this breakpoint for all the threads that had already set
+  // it successfully.
   std::vector<NativeThreadProtocol *> breakpoint_established_threads;
 
-  // Request to set a hardware breakpoint for each of current process threads.
+  // Request to set a hardware breakpoint for each of current process
+  // threads.
   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
   for (const auto &thread : m_threads) {
     assert(thread && "thread list should not have a NULL thread!");
 
     Status thread_error = thread->SetHardwareBreakpoint(addr, size);
     if (thread_error.Success()) {
-      // Remember that we set this breakpoint successfully in
-      // case we need to clear it later.
+      // Remember that we set this breakpoint successfully in case we need
+      // to clear it later.
       breakpoint_established_threads.push_back(thread.get());
     } else {
-      // Unset the breakpoint for each thread we successfully
-      // set so that we get back to a consistent state of "not
-      // set" for this hardware breakpoint.
+      // Unset the breakpoint for each thread we successfully set so that
+      // we get back to a consistent state of "not set" for this hardware
+      // breakpoint.
       for (auto rollback_thread_sp : breakpoint_established_threads) {
         Status remove_error =
             rollback_thread_sp->RemoveHardwareBreakpoint(addr);
@@ -274,8 +277,8 @@
     }
   }
 
-  // Register new hardware breakpoint into hardware breakpoints map of current
-  // process.
+  // Register new hardware breakpoint into hardware breakpoints map of
+  // current process.
   m_hw_breakpoints_map[addr] = {addr, size};
 
   return Status();
@@ -409,9 +412,9 @@
     ++m_stop_id;
 
     // Give process a chance to do any stop id bump processing, such as
-    // clearing cached data that is invalidated each time the process runs.
-    // Note if/when we support some threads running, we'll end up needing
-    // to manage this per thread and per process.
+    // clearing cached data that is invalidated each time the process
+    // runs. Note if/when we support some threads running, we'll end up
+    // needing to manage this per thread and per process.
     DoStopIDBumped(m_stop_id);
   }
 
Index: source/Host/common/NativeRegisterContext.cpp
===================================================================
--- source/Host/common/NativeRegisterContext.cpp
+++ source/Host/common/NativeRegisterContext.cpp
@@ -33,8 +33,7 @@
 // NativeRegisterContext.
 
 // void
-// NativeRegisterContext::InvalidateIfNeeded (bool force)
-// {
+// NativeRegisterContext::InvalidateIfNeeded (bool force) {
 //     ProcessSP process_sp (m_thread.GetProcess());
 //     bool invalidate = force;
 //     uint32_t process_stop_id = UINT32_MAX;
@@ -102,8 +101,8 @@
       const uint32_t reg_num = reg_set->registers[reg_num_index];
       // FIXME double check we're checking the right register kind here.
       if (reg_info->kinds[RegisterKind::eRegisterKindLLDB] == reg_num) {
-        // The given register is a member of this register set.  Return the
-        // register set name.
+        // The given register is a member of this register set.  Return
+        // the register set name.
         return reg_set->name;
       }
     }
@@ -362,11 +361,11 @@
     return error;
   }
 
-  // We now have a memory buffer that contains the part or all of the register
-  // value. Set the register value using this memory data.
-  // TODO: we might need to add a parameter to this function in case the byte
-  // order of the memory data doesn't match the process. For now we are assuming
-  // they are the same.
+  // We now have a memory buffer that contains the part or all of the
+  // register value. Set the register value using this memory data. TODO:
+  // we might need to add a parameter to this function in case the byte
+  // order of the memory data doesn't match the process. For now we are
+  // assuming they are the same.
   reg_value.SetFromMemoryData(reg_info, src, src_len, process.GetByteOrder(),
                               error);
 
@@ -383,10 +382,9 @@
 
   NativeProcessProtocol &process = m_thread.GetProcess();
 
-  // TODO: we might need to add a parameter to this function in case the byte
-  // order of the memory data doesn't match the process. For now we are
-  // assuming
-  // they are the same.
+  // TODO: we might need to add a parameter to this function in case the
+  // byte order of the memory data doesn't match the process. For now we
+  // are assuming they are the same.
   const size_t bytes_copied = reg_value.GetAsMemoryData(
       reg_info, dst, dst_len, process.GetByteOrder(), error);
 
Index: source/Host/common/PseudoTerminal.cpp
===================================================================
--- source/Host/common/PseudoTerminal.cpp
+++ source/Host/common/PseudoTerminal.cpp
@@ -35,10 +35,10 @@
 //----------------------------------------------------------------------
 // Destructor
 //
-// The destructor will close the master and slave file descriptors
-// if they are valid and ownership has not been released using the
-// ReleaseMasterFileDescriptor() or the ReleaseSaveFileDescriptor()
-// member functions.
+// The destructor will close the master and slave file descriptors if they
+// are valid and ownership has not been released using the
+// ReleaseMasterFileDescriptor() or the ReleaseSaveFileDescriptor() member
+// functions.
 //----------------------------------------------------------------------
 PseudoTerminal::~PseudoTerminal() {
   CloseMasterFileDescriptor();
@@ -66,15 +66,15 @@
 }
 
 //----------------------------------------------------------------------
-// Open the first available pseudo terminal with OFLAG as the
-// permissions. The file descriptor is stored in this object and can
-// be accessed with the MasterFileDescriptor() accessor. The
-// ownership of the master file descriptor can be released using
-// the ReleaseMasterFileDescriptor() accessor. If this object has
-// a valid master files descriptor when its destructor is called, it
-// will close the master file descriptor, therefore clients must
-// call ReleaseMasterFileDescriptor() if they wish to use the master
-// file descriptor after this object is out of scope or destroyed.
+// Open the first available pseudo terminal with OFLAG as the permissions.
+// The file descriptor is stored in this object and can be accessed with
+// the MasterFileDescriptor() accessor. The ownership of the master file
+// descriptor can be released using the ReleaseMasterFileDescriptor()
+// accessor. If this object has a valid master files descriptor when its
+// destructor is called, it will close the master file descriptor,
+// therefore clients must call ReleaseMasterFileDescriptor() if they wish
+// to use the master file descriptor after this object is out of scope or
+// destroyed.
 //
 // RETURNS:
 //  True when successful, false indicating an error occurred.
@@ -118,11 +118,11 @@
 }
 
 //----------------------------------------------------------------------
-// Open the slave pseudo terminal for the current master pseudo
-// terminal. A master pseudo terminal should already be valid prior to
-// calling this function (see OpenFirstAvailableMaster()).
-// The file descriptor is stored this object's member variables and can
-// be accessed via the GetSlaveFileDescriptor(), or released using the
+// Open the slave pseudo terminal for the current master pseudo terminal.
+// A master pseudo terminal should already be valid prior to calling this
+// function (see OpenFirstAvailableMaster()). The file descriptor is
+// stored this object's member variables and can be accessed via the
+// GetSlaveFileDescriptor(), or released using the
 // ReleaseSlaveFileDescriptor() member function.
 //
 // RETURNS:
@@ -185,18 +185,17 @@
 // Fork a child process and have its stdio routed to a pseudo terminal.
 //
 // In the parent process when a valid pid is returned, the master file
-// descriptor can be used as a read/write access to stdio of the
-// child process.
+// descriptor can be used as a read/write access to stdio of the child
+// process.
 //
-// In the child process the stdin/stdout/stderr will already be routed
-// to the slave pseudo terminal and the master file descriptor will be
-// closed as it is no longer needed by the child process.
+// In the child process the stdin/stdout/stderr will already be routed to
+// the slave pseudo terminal and the master file descriptor will be closed
+// as it is no longer needed by the child process.
 //
-// This class will close the file descriptors for the master/slave
-// when the destructor is called, so be sure to call
+// This class will close the file descriptors for the master/slave when
+// the destructor is called, so be sure to call
 // ReleaseMasterFileDescriptor() or ReleaseSlaveFileDescriptor() if any
-// file descriptors are going to be used past the lifespan of this
-// object.
+// file descriptors are going to be used past the lifespan of this object.
 //
 // RETURNS:
 //  in the parent process: the pid of the child, or -1 if fork fails
@@ -235,7 +234,8 @@
             ::strerror_r(errno, error_str, error_len);
         }
 #endif
-        // Duplicate all stdio file descriptors to the slave pseudo terminal
+        // Duplicate all stdio file descriptors to the slave pseudo
+        // terminal
         if (::dup2(m_slave_fd, STDIN_FILENO) != STDIN_FILENO) {
           if (error_str && !error_str[0])
             ::strerror_r(errno, error_str, error_len);
@@ -261,49 +261,49 @@
 }
 
 //----------------------------------------------------------------------
-// The master file descriptor accessor. This object retains ownership
-// of the master file descriptor when this accessor is used. Use
+// The master file descriptor accessor. This object retains ownership of
+// the master file descriptor when this accessor is used. Use
 // ReleaseMasterFileDescriptor() if you wish this object to release
 // ownership of the master file descriptor.
 //
-// Returns the master file descriptor, or -1 if the master file
-// descriptor is not currently valid.
+// Returns the master file descriptor, or -1 if the master file descriptor
+// is not currently valid.
 //----------------------------------------------------------------------
 int PseudoTerminal::GetMasterFileDescriptor() const { return m_master_fd; }
 
 //----------------------------------------------------------------------
 // The slave file descriptor accessor.
 //
-// Returns the slave file descriptor, or -1 if the slave file
-// descriptor is not currently valid.
+// Returns the slave file descriptor, or -1 if the slave file descriptor
+// is not currently valid.
 //----------------------------------------------------------------------
 int PseudoTerminal::GetSlaveFileDescriptor() const { return m_slave_fd; }
 
 //----------------------------------------------------------------------
-// Release ownership of the master pseudo terminal file descriptor
-// without closing it. The destructor for this class will close the
-// master file descriptor if the ownership isn't released using this
-// call and the master file descriptor has been opened.
+// Release ownership of the master pseudo terminal file descriptor without
+// closing it. The destructor for this class will close the master file
+// descriptor if the ownership isn't released using this call and the
+// master file descriptor has been opened.
 //----------------------------------------------------------------------
 int PseudoTerminal::ReleaseMasterFileDescriptor() {
-  // Release ownership of the master pseudo terminal file
-  // descriptor without closing it. (the destructor for this
-  // class will close it otherwise!)
+  // Release ownership of the master pseudo terminal file descriptor
+  // without closing it. (the destructor for this class will close it
+  // otherwise!)
   int fd = m_master_fd;
   m_master_fd = invalid_fd;
   return fd;
 }
 
 //----------------------------------------------------------------------
-// Release ownership of the slave pseudo terminal file descriptor
-// without closing it. The destructor for this class will close the
-// slave file descriptor if the ownership isn't released using this
-// call and the slave file descriptor has been opened.
+// Release ownership of the slave pseudo terminal file descriptor without
+// closing it. The destructor for this class will close the slave file
+// descriptor if the ownership isn't released using this call and the
+// slave file descriptor has been opened.
 //----------------------------------------------------------------------
 int PseudoTerminal::ReleaseSlaveFileDescriptor() {
-  // Release ownership of the slave pseudo terminal file
-  // descriptor without closing it (the destructor for this
-  // class will close it otherwise!)
+  // Release ownership of the slave pseudo terminal file descriptor
+  // without closing it (the destructor for this class will close it
+  // otherwise!)
   int fd = m_slave_fd;
   m_slave_fd = invalid_fd;
   return fd;
Index: source/Host/common/Socket.cpp
===================================================================
--- source/Host/common/Socket.cpp
+++ source/Host/common/Socket.cpp
@@ -160,18 +160,17 @@
 
   error = listen_socket->Listen(host_and_port, backlog);
   if (error.Success()) {
-    // We were asked to listen on port zero which means we
-    // must now read the actual port that was given to us
-    // as port zero is a special code for "find an open port
-    // for me".
+    // We were asked to listen on port zero which means we must now read
+    // the actual port that was given to us as port zero is a special code
+    // for "find an open port for me".
     if (port == 0)
       port = listen_socket->GetLocalPortNumber();
 
-    // Set the port predicate since when doing a listen://<host>:<port>
-    // it often needs to accept the incoming connection which is a blocking
-    // system call. Allowing access to the bound port using a predicate allows
-    // us to wait for the port predicate to be set to a non-zero value from
-    // another thread in an efficient manor.
+    // Set the port predicate since when doing a listen://<host>:<port> it
+    // often needs to accept the incoming connection which is a blocking
+    // system call. Allowing access to the bound port using a predicate
+    // allows us to wait for the port predicate to be set to a non-zero
+    // value from another thread in an efficient manor.
     if (predicate)
       predicate->SetValue(port, eBroadcastAlways);
     socket = listen_socket.release();
@@ -282,8 +281,7 @@
   }
 
   // If this was unsuccessful, then check if it's simply a signed 32-bit
-  // integer, representing
-  // a port with an empty host.
+  // integer, representing a port with an empty host.
   host_str.clear();
   port_str.clear();
   bool ok = false;
@@ -436,11 +434,11 @@
   error.Clear();
 #if defined(ANDROID_USE_ACCEPT_WORKAROUND)
   // Hack:
-  // This enables static linking lldb-server to an API 21 libc, but still having
-  // it run on older devices. It is necessary because API 21 libc's
+  // This enables static linking lldb-server to an API 21 libc, but still
+  // having it run on older devices. It is necessary because API 21 libc's
   // implementation of accept() uses the accept4 syscall(), which is not
-  // available in older kernels. Using an older libc would fix this issue, but
-  // introduce other ones, as the old libraries were quite buggy.
+  // available in older kernels. Using an older libc would fix this issue,
+  // but introduce other ones, as the old libraries were quite buggy.
   int fd = syscall(__NR_accept, sockfd, addr, addrlen);
   if (fd >= 0 && !child_processes_inherit) {
     int flags = ::fcntl(fd, F_GETFD);
Index: source/Host/common/SocketAddress.cpp
===================================================================
--- source/Host/common/SocketAddress.cpp
+++ source/Host/common/SocketAddress.cpp
@@ -7,7 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// Note: This file is used on Darwin by debugserver, so it needs to remain as
+// Note: This file is used on Darwin by debugserver, so it needs to remain
+// as
 //       self contained as possible, and devoid of references to LLVM unless 
 //       there is compelling reason.
 //
Index: source/Host/common/SoftwareBreakpoint.cpp
===================================================================
--- source/Host/common/SoftwareBreakpoint.cpp
+++ source/Host/common/SoftwareBreakpoint.cpp
@@ -33,9 +33,8 @@
     return Status("SoftwareBreakpoint::%s invalid load address specified.",
                   __FUNCTION__);
 
-  // Ask the NativeProcessProtocol subclass to fill in the correct software
-  // breakpoint
-  // trap for the breakpoint site.
+  // Ask the NativeProcessProtocol subclass to fill in the correct
+  // software breakpoint trap for the breakpoint site.
   size_t bp_opcode_size = 0;
   const uint8_t *bp_opcode_bytes = NULL;
   Status error = process.GetSoftwareBreakpointTrapOpcode(
@@ -98,9 +97,8 @@
     log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64 " -- SUCCESS",
                 __FUNCTION__, addr);
 
-  // Set the breakpoint and verified it was written properly.  Now
-  // create a breakpoint remover that understands how to undo this
-  // breakpoint.
+  // Set the breakpoint and verified it was written properly.  Now create
+  // a breakpoint remover that understands how to undo this breakpoint.
   breakpoint_sp.reset(new SoftwareBreakpoint(process, addr, saved_opcode_bytes,
                                              bp_opcode_bytes, bp_opcode_size));
   return Status();
@@ -297,8 +295,8 @@
       } else {
         error.SetErrorString(
             "Original breakpoint trap is no longer in memory.");
-        // Set verify to true and so we can check if the original opcode has
-        // already been restored
+        // Set verify to true and so we can check if the original opcode
+        // has already been restored
         verify = true;
       }
 
Index: source/Host/common/Symbols.cpp
===================================================================
--- source/Host/common/Symbols.cpp
+++ source/Host/common/Symbols.cpp
@@ -111,19 +111,19 @@
 
           // Add a ".dSYM" name to each directory component of the path,
           // stripping off components.  e.g. we may have a binary like
-          // /S/L/F/Foundation.framework/Versions/A/Foundation
-          // and
+          // /S/L/F/Foundation.framework/Versions/A/Foundation and
           // /S/L/F/Foundation.framework.dSYM
           //
-          // so we'll need to start with /S/L/F/Foundation.framework/Versions/A,
-          // add the .dSYM part to the "A", and if that doesn't exist, strip off
-          // the "A" and try it again with "Versions", etc., until we find a
-          // dSYM bundle or we've stripped off enough path components that
-          // there's no need to continue.
+          // so we'll need to start with
+          // /S/L/F/Foundation.framework/Versions/A, add the .dSYM part to
+          // the "A", and if that doesn't exist, strip off the "A" and try
+          // it again with "Versions", etc., until we find a dSYM bundle
+          // or we've stripped off enough path components that there's no
+          // need to continue.
 
           for (int i = 0; i < 4; i++) {
-            // Does this part of the path have a "." character - could it be a
-            // bundle's top level directory?
+            // Does this part of the path have a "." character - could it
+            // be a bundle's top level directory?
             const char *fn = parent_dirs.GetFilename().AsCString();
             if (fn == nullptr)
               break;
@@ -131,7 +131,8 @@
               dsym_fspec = parent_dirs;
               dsym_fspec.RemoveLastPathComponent();
 
-              // If the current directory name is "Foundation.framework", see if
+              // If the current directory name is "Foundation.framework",
+              // see if
               // "Foundation.framework.dSYM/Contents/Resources/DWARF/Foundation"
               // exists & has the right uuid.
               std::string dsym_fn = fn;
@@ -177,8 +178,8 @@
 
   FileSpec symbol_fspec;
   ModuleSpec dsym_module_spec;
-  // First try and find the dSYM in the same directory as the executable or in
-  // an appropriate parent directory
+  // First try and find the dSYM in the same directory as the executable
+  // or in an appropriate parent directory
   if (LocateDSYMInVincinityOfExecutable(module_spec, symbol_fspec) == false) {
     // We failed to easily find the dSYM above, so use DebugSymbols
     LocateMacOSXFilesUsingDebugSymbols(module_spec, dsym_module_spec);
@@ -293,10 +294,9 @@
           if (num_specs == 1) {
             ModuleSpec mspec;
             if (specs.GetModuleSpecAtIndex(0, mspec)) {
-              // Skip the uuids check if module_uuid is invalid.
-              // For example, this happens for *.dwp files since
-              // at the moment llvm-dwp doesn't output build ids,
-              // nor does binutils dwp.
+              // Skip the uuids check if module_uuid is invalid. For
+              // example, this happens for *.dwp files since at the moment
+              // llvm-dwp doesn't output build ids, nor does binutils dwp.
               if (!module_uuid.IsValid() || module_uuid == mspec.GetUUID())
                 return file_spec;
             }
Index: source/Host/common/TCPSocket.cpp
===================================================================
--- source/Host/common/TCPSocket.cpp
+++ source/Host/common/TCPSocket.cpp
@@ -85,8 +85,8 @@
 }
 
 std::string TCPSocket::GetLocalIPAddress() const {
-  // We bound to port zero, so we need to figure out which port we actually
-  // bound to
+  // We bound to port zero, so we need to figure out which port we
+  // actually bound to
   if (m_socket != kInvalidSocketValue) {
     SocketAddress sock_addr;
     socklen_t sock_addr_len = sock_addr.GetMaxLength();
@@ -107,8 +107,8 @@
 }
 
 std::string TCPSocket::GetRemoteIPAddress() const {
-  // We bound to port zero, so we need to figure out which port we actually
-  // bound to
+  // We bound to port zero, so we need to figure out which port we
+  // actually bound to
   if (m_socket != kInvalidSocketValue) {
     SocketAddress sock_addr;
     socklen_t sock_addr_len = sock_addr.GetMaxLength();
Index: source/Host/common/TaskPool.cpp
===================================================================
--- source/Host/common/TaskPool.cpp
+++ source/Host/common/TaskPool.cpp
@@ -49,8 +49,8 @@
 TaskPoolImpl::TaskPoolImpl() : m_thread_count(0) {}
 
 unsigned GetHardwareConcurrencyHint() {
-  // std::thread::hardware_concurrency may return 0
-  // if the value is not well defined or not computable.
+  // std::thread::hardware_concurrency may return 0 if the value is not
+  // well defined or not computable.
   static const unsigned g_hardware_concurrency = 
     std::max(1u, std::thread::hardware_concurrency());
   return g_hardware_concurrency;
@@ -63,9 +63,9 @@
   m_tasks.emplace(std::move(task_fn));
   if (m_thread_count < GetHardwareConcurrencyHint()) {
     m_thread_count++;
-    // Note that this detach call needs to happen with the m_tasks_mutex held.
-    // This prevents the thread
-    // from exiting prematurely and triggering a linux libc bug
+    // Note that this detach call needs to happen with the m_tasks_mutex
+    // held. This prevents the thread from exiting prematurely and
+    // triggering a linux libc bug
     // (https://sourceware.org/bugzilla/show_bug.cgi?id=19951).
     lldb_private::ThreadLauncher::LaunchThread("task-pool.worker", WorkerPtr,
                                                this, nullptr, min_stack_size)
Index: source/Host/common/Terminal.cpp
===================================================================
--- source/Host/common/Terminal.cpp
+++ source/Host/common/Terminal.cpp
@@ -107,9 +107,9 @@
 }
 
 //----------------------------------------------------------------------
-// Save the current state of the TTY for the file descriptor "fd"
-// and if "save_process_group" is true, attempt to save the process
-// group info for the TTY.
+// Save the current state of the TTY for the file descriptor "fd" and if
+// "save_process_group" is true, attempt to save the process group info
+// for the TTY.
 //----------------------------------------------------------------------
 bool TerminalState::Save(int fd, bool save_process_group) {
   m_tty.SetFileDescriptor(fd);
@@ -142,8 +142,8 @@
 }
 
 //----------------------------------------------------------------------
-// Restore the state of the TTY using the cached values from a
-// previous call to Save().
+// Restore the state of the TTY using the cached values from a previous
+// call to Save().
 //----------------------------------------------------------------------
 bool TerminalState::Restore() const {
 #ifndef LLDB_DISABLE_POSIX
@@ -173,8 +173,8 @@
 }
 
 //----------------------------------------------------------------------
-// Returns true if this object has valid saved TTY state settings
-// that can be used to restore a previous state.
+// Returns true if this object has valid saved TTY state settings that can
+// be used to restore a previous state.
 //----------------------------------------------------------------------
 bool TerminalState::IsValid() const {
   return m_tty.FileDescriptorIsValid() &&
@@ -249,8 +249,8 @@
 }
 
 //------------------------------------------------------------------
-// Save the state at index "idx" for file descriptor "fd" and
-// save the process group if requested.
+// Save the state at index "idx" for file descriptor "fd" and save the
+// process group if requested.
 //
 // Returns true if the restore was successful, false otherwise.
 //------------------------------------------------------------------
Index: source/Host/common/ThreadLauncher.cpp
===================================================================
--- source/Host/common/ThreadLauncher.cpp
+++ source/Host/common/ThreadLauncher.cpp
@@ -42,7 +42,8 @@
     error.SetError(::GetLastError(), eErrorTypeWin32);
 #else
 
-// ASAN instrumentation adds a lot of bookkeeping overhead on stack frames.
+// ASAN instrumentation adds a lot of bookkeeping overhead on stack
+// frames.
 #if __has_feature(address_sanitizer)
   const size_t eight_megabytes = 8 * 1024 * 1024;
   if (min_stack_byte_size < eight_megabytes) {
Index: source/Host/common/UDPSocket.cpp
===================================================================
--- source/Host/common/UDPSocket.cpp
+++ source/Host/common/UDPSocket.cpp
@@ -69,8 +69,8 @@
   if (!DecodeHostAndPort(name, host_str, port_str, port, &error))
     return error;
 
-  // At this point we have setup the receive port, now we need to
-  // setup the UDP send socket
+  // At this point we have setup the receive port, now we need to setup
+  // the UDP send socket
 
   struct addrinfo hints;
   struct addrinfo *service_info_list = nullptr;
@@ -112,8 +112,8 @@
 
   SocketAddress bind_addr;
 
-  // Only bind to the loopback address if we are expecting a connection from
-  // localhost to avoid any firewall issues.
+  // Only bind to the loopback address if we are expecting a connection
+  // from localhost to avoid any firewall issues.
   const bool bind_addr_success = (host_str == "127.0.0.1" || host_str == "localhost")
                                      ? bind_addr.SetToLocalhost(kDomain, port)
                                      : bind_addr.SetToAnyAddress(kDomain, port);
Index: source/Host/common/XML.cpp
===================================================================
--- source/Host/common/XML.cpp
+++ source/Host/common/XML.cpp
@@ -252,8 +252,8 @@
       if (node->type != XML_ELEMENT_NODE)
         continue;
 
-      // If name is nullptr, we take all nodes of type "t", else
-      // just the ones whose name matches
+      // If name is nullptr, we take all nodes of type "t", else just the
+      // ones whose name matches
       if (name) {
         if (strcmp((const char *)node->name, name) != 0)
           continue; // Name mismatch, ignore this one
Index: source/Host/freebsd/Host.cpp
===================================================================
--- source/Host/freebsd/Host.cpp
+++ source/Host/freebsd/Host.cpp
@@ -191,10 +191,10 @@
         kinfo.ki_flag & P_WEXIT)    // Working on exiting
       continue;
 
-    // Every thread is a process in FreeBSD, but all the threads of a single
-    // process have the same pid. Do not store the process info in the
-    // result list if a process with given identifier is already registered
-    // there.
+    // Every thread is a process in FreeBSD, but all the threads of a
+    // single process have the same pid. Do not store the process info in
+    // the result list if a process with given identifier is already
+    // registered there.
     bool already_registered = false;
     for (uint32_t pi = 0;
          !already_registered && (const int)kinfo.ki_numthreads > 1 &&
Index: source/Host/linux/Host.cpp
===================================================================
--- source/Host/linux/Host.cpp
+++ source/Host/linux/Host.cpp
@@ -61,7 +61,8 @@
     std::tie(Line, Rest) = Rest.split('\n');
 
     if (Line.consume_front("Gid:")) {
-      // Real, effective, saved set, and file system GIDs. Read the first two.
+      // Real, effective, saved set, and file system GIDs. Read the first
+      // two.
       Line = Line.ltrim();
       uint32_t RGid, EGid;
       Line.consumeInteger(10, RGid);
@@ -71,7 +72,8 @@
       ProcessInfo.SetGroupID(RGid);
       ProcessInfo.SetEffectiveGroupID(EGid);
     } else if (Line.consume_front("Uid:")) {
-      // Real, effective, saved set, and file system UIDs. Read the first two.
+      // Real, effective, saved set, and file system UIDs. Read the first
+      // two.
       Line = Line.ltrim();
       uint32_t RUid, EUid;
       Line.consumeInteger(10, RUid);
@@ -153,7 +155,8 @@
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
-  // We can't use getProcFile here because proc/[pid]/exe is a symbolic link.
+  // We can't use getProcFile here because proc/[pid]/exe is a symbolic
+  // link.
   llvm::SmallString<64> ProcExe;
   (llvm::Twine("/proc/") + llvm::Twine(pid) + "/exe").toVector(ProcExe);
   std::string ExePath(PATH_MAX, '\0');
@@ -166,8 +169,8 @@
   }
   ExePath.resize(len);
 
-  // If the binary has been deleted, the link name has " (deleted)" appended.
-  // Remove if there.
+  // If the binary has been deleted, the link name has " (deleted)"
+  // appended. Remove if there.
   llvm::StringRef PathRef = ExePath;
   PathRef.consume_back(" (deleted)");
 
@@ -246,8 +249,8 @@
       if (State == ProcessState::Zombie)
         continue;
 
-      // Check for user match if we're not matching all users and not running as
-      // root.
+      // Check for user match if we're not matching all users and not
+      // running as root.
       if (!all_users && (our_uid != 0) && (process_info.GetUserID() != our_uid))
         continue;
 
Index: source/Host/linux/HostInfoLinux.cpp
===================================================================
--- source/Host/linux/HostInfoLinux.cpp
+++ source/Host/linux/HostInfoLinux.cpp
@@ -56,9 +56,8 @@
       if (status == 3)
         success = true;
       else {
-        // Some kernels omit the update version, so try looking for just "X.Y"
-        // and
-        // set update to 0.
+        // Some kernels omit the update version, so try looking for just
+        // "X.Y" and set update to 0.
         g_fields->m_os_update = 0;
         status = sscanf(un.release, "%u.%u", &g_fields->m_os_major,
                         &g_fields->m_os_minor);
@@ -100,8 +99,8 @@
 }
 
 llvm::StringRef HostInfoLinux::GetDistributionId() {
-  // Try to run 'lbs_release -i', and use that response
-  // for the distribution id.
+  // Try to run 'lbs_release -i', and use that response for the
+  // distribution id.
   static llvm::once_flag g_once_flag;
   llvm::call_once(g_once_flag, []() {
 
@@ -109,8 +108,8 @@
     if (log)
       log->Printf("attempting to determine Linux distribution...");
 
-    // check if the lsb_release command exists at one of the
-    // following paths
+    // check if the lsb_release command exists at one of the following
+    // paths
     const char *const exe_paths[] = {"/bin/lsb_release",
                                      "/usr/bin/lsb_release"};
 
@@ -212,8 +211,9 @@
 
 bool HostInfoLinux::ComputeUserPluginsDirectory(FileSpec &file_spec) {
   // XDG Base Directory Specification
-  // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
-  // If XDG_DATA_HOME exists, use that, otherwise use ~/.local/share/lldb.
+  // http://standards.freedesktop.org/basedir-spec/basedir-spec-
+  // latest.html If XDG_DATA_HOME exists, use that, otherwise use
+  // ~/.local/share/lldb.
   const char *xdg_data_home = getenv("XDG_DATA_HOME");
   if (xdg_data_home && xdg_data_home[0]) {
     std::string user_plugin_dir(xdg_data_home);
@@ -230,8 +230,8 @@
 
   const char *distribution_id = GetDistributionId().data();
 
-  // On Linux, "unknown" in the vendor slot isn't what we want for the default
-  // triple.  It's probably an artifact of config.guess.
+  // On Linux, "unknown" in the vendor slot isn't what we want for the
+  // default triple.  It's probably an artifact of config.guess.
   if (arch_32.IsValid()) {
     arch_32.SetDistributionId(distribution_id);
     if (arch_32.GetTriple().getVendor() == llvm::Triple::UnknownVendor)
Index: source/Host/macosx/Symbols.cpp
===================================================================
--- source/Host/macosx/Symbols.cpp
+++ source/Host/macosx/Symbols.cpp
@@ -157,8 +157,8 @@
           }
 
           if (!success) {
-            // No dictionary, check near the dSYM bundle for an executable that
-            // matches...
+            // No dictionary, check near the dSYM bundle for an executable
+            // that matches...
             if (::CFURLGetFileSystemRepresentation(
                     dsym_url.get(), true, (UInt8 *)path, sizeof(path) - 1)) {
               char *dsym_extension_pos = ::strstr(path, ".dSYM");
@@ -340,14 +340,13 @@
     std::string DBGBuildSourcePath;
     std::string DBGSourcePath;
 
-    // If DBGVersion value 2 or higher, look for
-    // DBGSourcePathRemapping dictionary and append the key-value pairs
-    // to our remappings.
+    // If DBGVersion value 2 or higher, look for DBGSourcePathRemapping
+    // dictionary and append the key-value pairs to our remappings.
     cf_dict = (CFDictionaryRef)CFDictionaryGetValue(
         (CFDictionaryRef)uuid_dict, CFSTR("DBGSourcePathRemapping"));
     if (cf_dict && CFGetTypeID(cf_dict) == CFDictionaryGetTypeID()) {
-      // If we see DBGVersion with a value of 2 or higher, this is a new style
-      // DBGSourcePathRemapping dictionary
+      // If we see DBGVersion with a value of 2 or higher, this is a new
+      // style DBGSourcePathRemapping dictionary
       bool new_style_source_remapping_dictionary = false;
       bool do_truncate_remapping_names = false;
       std::string original_DBGSourcePath_value = DBGSourcePath;
@@ -389,10 +388,9 @@
           }
           if (!DBGBuildSourcePath.empty() && !DBGSourcePath.empty()) {
             // In the "old style" DBGSourcePathRemapping dictionary, the
-            // DBGSourcePath values
-            // (the "values" half of key-value path pairs) were wrong.  Ignore
-            // them and use the
-            // universal DBGSourcePath string from earlier.
+            // DBGSourcePath values (the "values" half of key-value path
+            // pairs) were wrong.  Ignore them and use the universal
+            // DBGSourcePath string from earlier.
             if (new_style_source_remapping_dictionary == true &&
                 !original_DBGSourcePath_value.empty()) {
               DBGSourcePath = original_DBGSourcePath_value;
@@ -401,10 +399,11 @@
               FileSpec resolved_source_path(DBGSourcePath.c_str(), true);
               DBGSourcePath = resolved_source_path.GetPath();
             }
-            // With version 2 of DBGSourcePathRemapping, we can chop off the
-            // last two filename parts from the source remapping and get a
-            // more general source remapping that still works. Add this as
-            // another option in addition to the full source path remap.
+            // With version 2 of DBGSourcePathRemapping, we can chop off
+            // the last two filename parts from the source remapping and
+            // get a more general source remapping that still works. Add
+            // this as another option in addition to the full source path
+            // remap.
             module_spec.GetSourceMappingList().Append(
                 ConstString(DBGBuildSourcePath.c_str()),
                 ConstString(DBGSourcePath.c_str()), true);
@@ -429,8 +428,8 @@
     }
 
 
-    // If we have a DBGBuildSourcePath + DBGSourcePath pair,
-    // append them to the source remappings list.
+    // If we have a DBGBuildSourcePath + DBGSourcePath pair, append them
+    // to the source remappings list.
 
     cf_str = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)uuid_dict,
                                                CFSTR("DBGBuildSourcePath"));
@@ -463,9 +462,8 @@
   const UUID *uuid_ptr = module_spec.GetUUIDPtr();
   const FileSpec *file_spec_ptr = module_spec.GetFileSpecPtr();
 
-  // It's expensive to check for the DBGShellCommands defaults setting, only do
-  // it once per
-  // lldb run and cache the result.
+  // It's expensive to check for the DBGShellCommands defaults setting,
+  // only do it once per lldb run and cache the result.
   static bool g_have_checked_for_dbgshell_command = false;
   static const char *g_dbgshell_command = NULL;
   if (g_have_checked_for_dbgshell_command == false) {
@@ -486,9 +484,8 @@
     }
   }
 
-  // When g_dbgshell_command is NULL, the user has not enabled the use of an
-  // external program
-  // to find the symbols, don't run it for them.
+  // When g_dbgshell_command is NULL, the user has not enabled the use of
+  // an external program to find the symbols, don't run it for them.
   if (force_lookup == false && g_dbgshell_command == NULL) {
     return false;
   }
Index: source/Host/macosx/cfcpp/CFCMutableDictionary.cpp
===================================================================
--- source/Host/macosx/cfcpp/CFCMutableDictionary.cpp
+++ source/Host/macosx/cfcpp/CFCMutableDictionary.cpp
@@ -243,8 +243,8 @@
                                          bool can_create) {
   CFMutableDictionaryRef dict = Dictionary(can_create);
   if (dict != NULL) {
-    // Have to promote to the next size type so things don't appear negative of
-    // the MSBit is set...
+    // Have to promote to the next size type so things don't appear
+    // negative of the MSBit is set...
     int16_t sval = value;
     CFCReleaser<CFNumberRef> cf_number(
         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &sval));
@@ -261,8 +261,8 @@
                                          bool can_create) {
   CFMutableDictionaryRef dict = Dictionary(can_create);
   if (dict != NULL) {
-    // Have to promote to the next size type so things don't appear negative of
-    // the MSBit is set...
+    // Have to promote to the next size type so things don't appear
+    // negative of the MSBit is set...
     int16_t sval = value;
     CFCReleaser<CFNumberRef> cf_number(
         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &sval));
@@ -279,8 +279,8 @@
                                           bool can_create) {
   CFMutableDictionaryRef dict = Dictionary(can_create);
   if (dict != NULL) {
-    // Have to promote to the next size type so things don't appear negative of
-    // the MSBit is set...
+    // Have to promote to the next size type so things don't appear
+    // negative of the MSBit is set...
     int32_t sval = value;
     CFCReleaser<CFNumberRef> cf_number(
         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &sval));
@@ -297,8 +297,8 @@
                                           bool can_create) {
   CFMutableDictionaryRef dict = Dictionary(can_create);
   if (dict != NULL) {
-    // Have to promote to the next size type so things don't appear negative of
-    // the MSBit is set...
+    // Have to promote to the next size type so things don't appear
+    // negative of the MSBit is set...
     int32_t sval = value;
     CFCReleaser<CFNumberRef> cf_number(
         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &sval));
@@ -315,8 +315,8 @@
                                           bool can_create) {
   CFMutableDictionaryRef dict = Dictionary(can_create);
   if (dict != NULL) {
-    // Have to promote to the next size type so things don't appear negative of
-    // the MSBit is set...
+    // Have to promote to the next size type so things don't appear
+    // negative of the MSBit is set...
     int64_t sval = value;
     CFCReleaser<CFNumberRef> cf_number(
         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &sval));
@@ -333,8 +333,8 @@
                                           bool can_create) {
   CFMutableDictionaryRef dict = Dictionary(can_create);
   if (dict != NULL) {
-    // Have to promote to the next size type so things don't appear negative of
-    // the MSBit is set...
+    // Have to promote to the next size type so things don't appear
+    // negative of the MSBit is set...
     int64_t sval = value;
     CFCReleaser<CFNumberRef> cf_number(
         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &sval));
@@ -351,10 +351,9 @@
                                           bool can_create) {
   CFMutableDictionaryRef dict = Dictionary(can_create);
   if (dict != NULL) {
-    // The number may appear negative if the MSBit is set in "value". Due to a
-    // limitation of
-    // CFNumber, there isn't a way to have it show up otherwise as of this
-    // writing.
+    // The number may appear negative if the MSBit is set in "value". Due
+    // to a limitation of CFNumber, there isn't a way to have it show up
+    // otherwise as of this writing.
     CFCReleaser<CFNumberRef> cf_number(
         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &value));
     if (cf_number.get()) {
@@ -370,10 +369,9 @@
                                           bool can_create) {
   CFMutableDictionaryRef dict = Dictionary(can_create);
   if (dict != NULL) {
-    // The number may appear negative if the MSBit is set in "value". Due to a
-    // limitation of
-    // CFNumber, there isn't a way to have it show up otherwise as of this
-    // writing.
+    // The number may appear negative if the MSBit is set in "value". Due
+    // to a limitation of CFNumber, there isn't a way to have it show up
+    // otherwise as of this writing.
     CFCReleaser<CFNumberRef> cf_number(
         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &value));
     if (cf_number.get()) {
@@ -389,10 +387,9 @@
                                           bool can_create) {
   CFMutableDictionaryRef dict = Dictionary(can_create);
   if (dict != NULL) {
-    // The number may appear negative if the MSBit is set in "value". Due to a
-    // limitation of
-    // CFNumber, there isn't a way to have it show up otherwise as of this
-    // writing.
+    // The number may appear negative if the MSBit is set in "value". Due
+    // to a limitation of CFNumber, there isn't a way to have it show up
+    // otherwise as of this writing.
     CFCReleaser<CFNumberRef> cf_number(
         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &value));
     if (cf_number.get()) {
@@ -408,10 +405,9 @@
                                           bool can_create) {
   CFMutableDictionaryRef dict = Dictionary(can_create);
   if (dict != NULL) {
-    // The number may appear negative if the MSBit is set in "value". Due to a
-    // limitation of
-    // CFNumber, there isn't a way to have it show up otherwise as of this
-    // writing.
+    // The number may appear negative if the MSBit is set in "value". Due
+    // to a limitation of CFNumber, there isn't a way to have it show up
+    // otherwise as of this writing.
     CFCReleaser<CFNumberRef> cf_number(
         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &value));
     if (cf_number.get()) {
Index: source/Host/macosx/cfcpp/CFCString.cpp
===================================================================
--- source/Host/macosx/cfcpp/CFCString.cpp
+++ source/Host/macosx/cfcpp/CFCString.cpp
@@ -88,13 +88,11 @@
   return CFCString::UTF8(get(), str);
 }
 
-// Static function that puts a copy of the UTF8 contents of CF_STR into STR
-// and returns the C string pointer that is contained in STR when successful,
-// else
-// NULL is returned. This allows the std::string parameter to own the extracted
-// string,
-// and also allows that string to be returned as a C string pointer that can be
-// used.
+// Static function that puts a copy of the UTF8 contents of CF_STR into
+// STR and returns the C string pointer that is contained in STR when
+// successful, else NULL is returned. This allows the std::string
+// parameter to own the extracted string, and also allows that string to
+// be returned as a C string pointer that can be used.
 
 const char *CFCString::UTF8(CFStringRef cf_str, std::string &str) {
   if (cf_str) {
@@ -127,11 +125,11 @@
   return expanded_path.c_str();
 }
 
-// Static function that puts a copy of the file system representation of CF_STR
-// into STR and returns the C string pointer that is contained in STR when
-// successful, else NULL is returned. This allows the std::string parameter
-// to own the extracted string, and also allows that string to be returned as
-// a C string pointer that can be used.
+// Static function that puts a copy of the file system representation of
+// CF_STR into STR and returns the C string pointer that is contained in
+// STR when successful, else NULL is returned. This allows the std::string
+// parameter to own the extracted string, and also allows that string to
+// be returned as a C string pointer that can be used.
 
 const char *CFCString::FileSystemRepresentation(CFStringRef cf_str,
                                                 std::string &str) {
Index: source/Host/netbsd/Host.cpp
===================================================================
--- source/Host/netbsd/Host.cpp
+++ source/Host/netbsd/Host.cpp
@@ -160,7 +160,8 @@
 
   const bool all_users =
       match_info.GetMatchAllUsers() ||
-      // Special case, if lldb is being run as root we can attach to anything
+      // Special case, if lldb is being run as root we can attach to
+      // anything
       (our_uid == 0);
 
   kvm_t *kdp;
@@ -191,10 +192,10 @@
         proc_kinfo[i].p_flag & P_WEXIT)    // Working on exiting
       continue;
 
-    // Every thread is a process in NetBSD, but all the threads of a single
-    // process have the same pid. Do not store the process info in the
-    // result list if a process with given identifier is already registered
-    // there.
+    // Every thread is a process in NetBSD, but all the threads of a
+    // single process have the same pid. Do not store the process info in
+    // the result list if a process with given identifier is already
+    // registered there.
     if (proc_kinfo[i].p_nlwps > 1) {
       bool already_registered = false;
       for (size_t pi = 0; pi < process_infos.GetSize(); pi++) {
Index: source/Host/posix/ConnectionFileDescriptorPosix.cpp
===================================================================
--- source/Host/posix/ConnectionFileDescriptorPosix.cpp
+++ source/Host/posix/ConnectionFileDescriptorPosix.cpp
@@ -8,9 +8,9 @@
 //===----------------------------------------------------------------------===//
 
 #if defined(__APPLE__)
-// Enable this special support for Apple builds where we can have unlimited
-// select bounds. We tried switching to poll() and kqueue and we were panicing
-// the kernel, so we have to stick with select for now.
+// Enable this special support for Apple builds where we can have
+// unlimited select bounds. We tried switching to poll() and kqueue and we
+// were panicing the kernel, so we have to stick with select for now.
 #define _DARWIN_UNLIMITED_SELECT
 #endif
 
@@ -194,10 +194,10 @@
       int fd = -1;
 
       if (!addr->getAsInteger(0, fd)) {
-        // We have what looks to be a valid file descriptor, but we
-        // should make sure it is. We currently are doing this by trying to
-        // get the flags from the file descriptor and making sure it
-        // isn't a bad fd.
+        // We have what looks to be a valid file descriptor, but we should
+        // make sure it is. We currently are doing this by trying to get
+        // the flags from the file descriptor and making sure it isn't a
+        // bad fd.
         errno = 0;
         int flags = ::fcntl(fd, F_GETFL, 0);
         if (flags == -1 || errno == EBADF) {
@@ -208,20 +208,19 @@
           m_write_sp.reset();
           return eConnectionStatusError;
         } else {
-          // Don't take ownership of a file descriptor that gets passed
-          // to us since someone else opened the file descriptor and
-          // handed it to us.
-          // TODO: Since are using a URL to open connection we should
-          // eventually parse options using the web standard where we
-          // have "fd://123?opt1=value;opt2=value" and we can have an
+          // Don't take ownership of a file descriptor that gets passed to
+          // us since someone else opened the file descriptor and handed
+          // it to us. TODO: Since are using a URL to open connection we
+          // should eventually parse options using the web standard where
+          // we have "fd://123?opt1=value;opt2=value" and we can have an
           // option be "owns=1" or "owns=0" or something like this to
-          // allow us to specify this. For now, we assume we must
-          // assume we don't own it.
+          // allow us to specify this. For now, we assume we must assume
+          // we don't own it.
 
           std::unique_ptr<TCPSocket> tcp_socket;
           tcp_socket.reset(new TCPSocket(fd, false, false));
-          // Try and get a socket option from this file descriptor to
-          // see if this is a socket and set m_is_socket accordingly.
+          // Try and get a socket option from this file descriptor to see
+          // if this is a socket and set m_is_socket accordingly.
           int resuse;
           bool is_socket =
               !!tcp_socket->GetOption(SOL_SOCKET, SO_REUSEADDR, resuse);
@@ -320,13 +319,11 @@
       m_read_sp->GetFdType() == IOObject::eFDTypeSocket)
     static_cast<Socket &>(*m_read_sp).PreDisconnect();
 
-  // Try to get the ConnectionFileDescriptor's mutex.  If we fail, that is quite
-  // likely
-  // because somebody is doing a blocking read on our file descriptor.  If
-  // that's the case,
-  // then send the "q" char to the command file channel so the read will wake up
-  // and the connection
-  // will then know to shut down.
+  // Try to get the ConnectionFileDescriptor's mutex.  If we fail, that is
+  // quite likely because somebody is doing a blocking read on our file
+  // descriptor.  If that's the case, then send the "q" char to the
+  // command file channel so the read will wake up and the connection will
+  // then know to shut down.
 
   m_shutting_down = true;
 
@@ -445,7 +442,8 @@
     case EBADF:      // fildes is not a valid file or socket descriptor open for
                      // reading.
     case ENXIO:      // An action is requested of a device that does not exist..
-                     // A requested action cannot be performed by the device.
+                     // A requested action cannot be performed by the
+                     // device.
     case ECONNRESET: // The connection is closed by the peer during a read
                      // attempt on a socket.
     case ENOTCONN:   // A read is attempted on an unconnected socket.
@@ -549,16 +547,16 @@
 ConnectionStatus
 ConnectionFileDescriptor::BytesAvailable(const Timeout<std::micro> &timeout,
                                          Status *error_ptr) {
-  // Don't need to take the mutex here separately since we are only called from
-  // Read.  If we
-  // ever get used more generally we will need to lock here as well.
+  // Don't need to take the mutex here separately since we are only called
+  // from Read.  If we ever get used more generally we will need to lock
+  // here as well.
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_CONNECTION));
   LLDB_LOG(log, "this = {0}, timeout = {1}", this, timeout);
 
-  // Make a copy of the file descriptors to make sure we don't
-  // have another thread change these values out from under us
-  // and cause problems in the loop below where like in FS_SET()
+  // Make a copy of the file descriptors to make sure we don't have
+  // another thread change these values out from under us and cause
+  // problems in the loop below where like in FS_SET()
   const IOObject::WaitableHandle handle = m_read_sp->GetWaitableHandle();
   const int pipe_fd = m_pipe.GetReadFileDescriptor();
 
@@ -569,11 +567,10 @@
 
     select_helper.FDSetRead(handle);
 #if defined(_MSC_VER)
-    // select() won't accept pipes on Windows.  The entire Windows codepath
-    // needs to be
-    // converted over to using WaitForMultipleObjects and event HANDLEs, but for
-    // now at least
-    // this will allow ::select() to not return an error.
+    // select() won't accept pipes on Windows.  The entire Windows
+    // codepath needs to be converted over to using WaitForMultipleObjects
+    // and event HANDLEs, but for now at least this will allow ::select()
+    // to not return an error.
     const bool have_pipe_fd = false;
 #else
     const bool have_pipe_fd = pipe_fd >= 0;
@@ -606,8 +603,7 @@
                      // allocate the requested number of file descriptors,
                      // or we have non-blocking IO
         case EINTR:  // A signal was delivered before the time limit
-          // expired and before any of the selected events
-          // occurred.
+          // expired and before any of the selected events occurred.
           break; // Lets keep reading to until we timeout
         }
       } else {
Index: source/Host/posix/DomainSocket.cpp
===================================================================
--- source/Host/posix/DomainSocket.cpp
+++ source/Host/posix/DomainSocket.cpp
@@ -42,8 +42,8 @@
   memcpy(saddr_un->sun_path + name_offset, name.data(), name.size());
 
   // For domain sockets we can use SUN_LEN in order to calculate size of
-  // sockaddr_un, but for abstract sockets we have to calculate size manually
-  // because of leading null symbol.
+  // sockaddr_un, but for abstract sockets we have to calculate size
+  // manually because of leading null symbol.
   if (name_offset == 0)
     saddr_un_len = SUN_LEN(saddr_un);
   else
Index: source/Host/posix/HostInfoPosix.cpp
===================================================================
--- source/Host/posix/HostInfoPosix.cpp
+++ source/Host/posix/HostInfoPosix.cpp
@@ -102,9 +102,8 @@
       return group_name.c_str();
     }
   } else {
-    // The threadsafe version isn't currently working for me on darwin, but the
-    // non-threadsafe version
-    // is, so I am calling it below.
+    // The threadsafe version isn't currently working for me on darwin,
+    // but the non-threadsafe version is, so I am calling it below.
     group_info_ptr = ::getgrgid(gid);
     if (group_info_ptr) {
       group_name.assign(group_info_ptr->gr_name);
@@ -140,9 +139,10 @@
   // drop library directory
   llvm::StringRef parent_path = llvm::sys::path::parent_path(raw_path);
 
-  // Most Posix systems (e.g. Linux/*BSD) will attempt to replace a */lib with
-  // */bin as the base directory for helper exe programs.  This will fail if the
-  // /lib and /bin directories are rooted in entirely different trees.
+  // Most Posix systems (e.g. Linux/*BSD) will attempt to replace a */lib
+  // with */bin as the base directory for helper exe programs.  This will
+  // fail if the /lib and /bin directories are rooted in entirely
+  // different trees.
   if (log)
     log->Printf("HostInfoPosix::ComputePathRelativeToLibrary() attempting to "
                 "derive the %s path from this path: %s",
@@ -192,9 +192,9 @@
   lldb_file_spec.GetPath(raw_path, sizeof(raw_path));
 
 #if defined(LLDB_PYTHON_RELATIVE_LIBDIR)
-  // Build the path by backing out of the lib dir, then building
-  // with whatever the real python interpreter uses.  (e.g. lib
-  // for most, lib64 on RHEL x86_64).
+  // Build the path by backing out of the lib dir, then building with
+  // whatever the real python interpreter uses.  (e.g. lib for most, lib64
+  // on RHEL x86_64).
   char python_path[PATH_MAX];
   ::snprintf(python_path, sizeof(python_path), "%s/../%s", raw_path,
              LLDB_PYTHON_RELATIVE_LIBDIR);
@@ -210,7 +210,8 @@
   os << "/python" << PY_MAJOR_VERSION << '.' << PY_MINOR_VERSION
      << "/site-packages";
 
-  // We may get our string truncated. Should we protect this with an assert?
+  // We may get our string truncated. Should we protect this with an
+  // assert?
   ::strncat(raw_path, python_version_dir.c_str(),
             sizeof(raw_path) - strlen(raw_path) - 1);
 
Index: source/Host/posix/HostProcessPosix.cpp
===================================================================
--- source/Host/posix/HostProcessPosix.cpp
+++ source/Host/posix/HostProcessPosix.cpp
@@ -66,8 +66,8 @@
   if (!error.Success())
     return error;
 
-  // If the binary has been deleted, the link name has " (deleted)" appended.
-  // Remove if there.
+  // If the binary has been deleted, the link name has " (deleted)"
+  // appended. Remove if there.
   if (file_spec.GetFilename().GetStringRef().endswith(" (deleted)")) {
     const char *filename = file_spec.GetFilename().GetCString();
     static const size_t deleted_len = strlen(" (deleted)");
@@ -83,7 +83,8 @@
   if (m_process == kInvalidPosixProcess)
     return false;
 
-  // Send this process the null signal.  If it succeeds the process is running.
+  // Send this process the null signal.  If it succeeds the process is
+  // running.
   Status error = Signal(0);
   return error.Success();
 }
Index: source/Host/posix/PipePosix.cpp
===================================================================
--- source/Host/posix/PipePosix.cpp
+++ source/Host/posix/PipePosix.cpp
@@ -36,8 +36,8 @@
 
 enum PIPES { READ, WRITE }; // Constants 0 and 1 for READ and WRITE
 
-// pipe2 is supported by a limited set of platforms
-// TODO: Add more platforms that support pipe2.
+// pipe2 is supported by a limited set of platforms TODO: Add more
+// platforms that support pipe2.
 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD__ >= 10) ||       \
     defined(__NetBSD__)
 #define PIPE2_SUPPORTED 1
@@ -136,9 +136,9 @@
     tmpdir_file_spec.AppendPathComponent(pipe_spec.c_str());
   }
 
-  // It's possible that another process creates the target path after we've
-  // verified it's available but before we create it, in which case we
-  // should try again.
+  // It's possible that another process creates the target path after
+  // we've verified it's available but before we create it, in which case
+  // we should try again.
   Status error;
   do {
     llvm::sys::fs::createUniqueFile(tmpdir_file_spec.GetPath(),
Index: source/Host/posix/ProcessLauncherPosixFork.cpp
===================================================================
--- source/Host/posix/ProcessLauncherPosixFork.cpp
+++ source/Host/posix/ProcessLauncherPosixFork.cpp
@@ -40,9 +40,9 @@
 
 static void FixupEnvironment(Environment &env) {
 #ifdef __ANDROID__
-  // If there is no PATH variable specified inside the environment then set the
-  // path to /system/bin. It is required because the default path used by
-  // execve() is wrong on android.
+  // If there is no PATH variable specified inside the environment then
+  // set the path to /system/bin. It is required because the default path
+  // used by execve() is wrong on android.
   env.try_emplace("PATH", "/system/bin");
 #endif
 }
@@ -131,8 +131,8 @@
   FixupEnvironment(env);
   Environment::Envp envp = env.getEnvp();
 
-  // Clear the signal mask to prevent the child from being affected by
-  // any masking done by the parent.
+  // Clear the signal mask to prevent the child from being affected by any
+  // masking done by the parent.
   sigset_t set;
   if (sigemptyset(&set) != 0 ||
       pthread_sigmask(SIG_SETMASK, &set, nullptr) != 0)
@@ -141,9 +141,8 @@
   if (info.GetFlags().Test(eLaunchFlagDebug)) {
     // HACK:
     // Close everything besides stdin, stdout, and stderr that has no file
-    // action to avoid leaking. Only do this when debugging, as elsewhere we
-    // actually rely on
-    // passing open descriptors to child processes.
+    // action to avoid leaking. Only do this when debugging, as elsewhere
+    // we actually rely on passing open descriptors to child processes.
     for (int fd = 3; fd < sysconf(_SC_OPEN_MAX); ++fd)
       if (!info.GetFileActionForFD(fd) && fd != error_fd)
         close(fd);
@@ -158,25 +157,21 @@
 
 #if defined(__linux__)
   if (errno == ETXTBSY) {
-    // On android M and earlier we can get this error because the adb deamon can
-    // hold a write
-    // handle on the executable even after it has finished uploading it. This
-    // state lasts
-    // only a short time and happens only when there are many concurrent adb
-    // commands being
-    // issued, such as when running the test suite. (The file remains open when
-    // someone does
-    // an "adb shell" command in the fork() child before it has had a chance to
-    // exec.) Since
-    // this state should clear up quickly, wait a while and then give it one
-    // more go.
+    // On android M and earlier we can get this error because the adb
+    // deamon can hold a write handle on the executable even after it has
+    // finished uploading it. This state lasts only a short time and
+    // happens only when there are many concurrent adb commands being
+    // issued, such as when running the test suite. (The file remains open
+    // when someone does an "adb shell" command in the fork() child before
+    // it has had a chance to exec.) Since this state should clear up
+    // quickly, wait a while and then give it one more go.
     usleep(50000);
     execve(argv[0], const_cast<char *const *>(argv), envp);
   }
 #endif
 
-  // ...unless exec fails.  In which case we definitely need to end the child
-  // here.
+  // ...unless exec fails.  In which case we definitely need to end the
+  // child here.
   ExitWithError(error_fd, "execve");
 }
 
Index: source/Host/windows/ConnectionGenericFileWindows.cpp
===================================================================
--- source/Host/windows/ConnectionGenericFileWindows.cpp
+++ source/Host/windows/ConnectionGenericFileWindows.cpp
@@ -20,13 +20,11 @@
 using namespace lldb_private;
 
 namespace {
-// This is a simple helper class to package up the information needed to return
-// from a Read/Write
-// operation function.  Since there is a lot of code to be run before exit
-// regardless of whether the
-// operation succeeded or failed, combined with many possible return paths, this
-// is the cleanest
-// way to represent it.
+// This is a simple helper class to package up the information needed to
+// return from a Read/Write operation function.  Since there is a lot of
+// code to be run before exit regardless of whether the operation
+// succeeded or failed, combined with many possible return paths, this is
+// the cleanest way to represent it.
 class ReturnInfo {
 public:
   void Set(size_t bytes, ConnectionStatus status, DWORD error_code) {
@@ -77,14 +75,13 @@
 void ConnectionGenericFile::InitializeEventHandles() {
   m_event_handles[kInterruptEvent] = CreateEvent(NULL, FALSE, FALSE, NULL);
 
-  // Note, we should use a manual reset event for the hEvent argument of the
-  // OVERLAPPED.  This
-  // is because both WaitForMultipleObjects and GetOverlappedResult (if you set
-  // the bWait
-  // argument to TRUE) will wait for the event to be signalled.  If we use an
-  // auto-reset event,
-  // WaitForMultipleObjects will reset the event, return successfully, and then
-  // GetOverlappedResult will block since the event is no longer signalled.
+  // Note, we should use a manual reset event for the hEvent argument of
+  // the OVERLAPPED.  This is because both WaitForMultipleObjects and
+  // GetOverlappedResult (if you set the bWait argument to TRUE) will wait
+  // for the event to be signalled.  If we use an auto-reset event,
+  // WaitForMultipleObjects will reset the event, return successfully, and
+  // then GetOverlappedResult will block since the event is no longer
+  // signalled.
   m_event_handles[kBytesAvailableEvent] =
       ::CreateEvent(NULL, TRUE, FALSE, NULL);
 }
@@ -113,10 +110,10 @@
       return status;
   }
 
-  // Open the file for overlapped access.  If it does not exist, create it.  We
-  // open it overlapped so that we can issue asynchronous reads and then use
-  // WaitForMultipleObjects to allow the read to be interrupted by an event
-  // object.
+  // Open the file for overlapped access.  If it does not exist, create
+  // it.  We open it overlapped so that we can issue asynchronous reads
+  // and then use WaitForMultipleObjects to allow the read to be
+  // interrupted by an event object.
   std::wstring wpath;
   if (!llvm::ConvertUTF8toWide(path, wpath)) {
     if (error_ptr)
@@ -146,19 +143,17 @@
   if (!IsConnected())
     return eConnectionStatusSuccess;
 
-  // Reset the handle so that after we unblock any pending reads, subsequent
-  // calls to Read() will
-  // see a disconnected state.
+  // Reset the handle so that after we unblock any pending reads,
+  // subsequent calls to Read() will see a disconnected state.
   HANDLE old_file = m_file;
   m_file = INVALID_HANDLE_VALUE;
 
-  // Set the disconnect event so that any blocking reads unblock, then cancel
-  // any pending IO operations.
+  // Set the disconnect event so that any blocking reads unblock, then
+  // cancel any pending IO operations.
   ::CancelIoEx(old_file, &m_overlapped);
 
-  // Close the file handle if we owned it, but don't close the event handles.
-  // We could always
-  // reconnect with the same Connection instance.
+  // Close the file handle if we owned it, but don't close the event
+  // handles. We could always reconnect with the same Connection instance.
   if (m_owns_file)
     ::CloseHandle(old_file);
 
@@ -189,9 +184,8 @@
   result = ::ReadFile(m_file, dst, dst_len, NULL, &m_overlapped);
   if (result || ::GetLastError() == ERROR_IO_PENDING) {
     if (!result) {
-      // The expected return path.  The operation is pending.  Wait for the
-      // operation to complete
-      // or be interrupted.
+      // The expected return path.  The operation is pending.  Wait for
+      // the operation to complete or be interrupted.
       DWORD milliseconds =
           timeout
               ? std::chrono::duration_cast<std::chrono::milliseconds>(*timeout)
@@ -200,8 +194,8 @@
       DWORD wait_result =
           ::WaitForMultipleObjects(llvm::array_lengthof(m_event_handles),
                                    m_event_handles, FALSE, milliseconds);
-      // All of the events are manual reset events, so make sure we reset them
-      // to non-signalled.
+      // All of the events are manual reset events, so make sure we reset
+      // them to non-signalled.
       switch (wait_result) {
       case WAIT_OBJECT_0 + kBytesAvailableEvent:
         break;
@@ -219,11 +213,10 @@
     // The data is ready.  Figure out how much was read and return;
     if (!::GetOverlappedResult(m_file, &m_overlapped, &bytes_read, FALSE)) {
       DWORD result_error = ::GetLastError();
-      // ERROR_OPERATION_ABORTED occurs when someone calls Disconnect() during a
-      // blocking read.
-      // This triggers a call to CancelIoEx, which causes the operation to
-      // complete and the
-      // result to be ERROR_OPERATION_ABORTED.
+      // ERROR_OPERATION_ABORTED occurs when someone calls Disconnect()
+      // during a blocking read. This triggers a call to CancelIoEx, which
+      // causes the operation to complete and the result to be
+      // ERROR_OPERATION_ABORTED.
       if (result_error == ERROR_HANDLE_EOF ||
           result_error == ERROR_OPERATION_ABORTED ||
           result_error == ERROR_BROKEN_PIPE)
@@ -250,9 +243,9 @@
   if (error_ptr)
     *error_ptr = return_info.GetError();
 
-  // kBytesAvailableEvent is a manual reset event.  Make sure it gets reset here
-  // so that any
-  // subsequent operations don't immediately see bytes available.
+  // kBytesAvailableEvent is a manual reset event.  Make sure it gets
+  // reset here so that any subsequent operations don't immediately see
+  // bytes available.
   ResetEvent(m_event_handles[kBytesAvailableEvent]);
 
   IncrementFilePointer(return_info.GetBytes());
@@ -284,7 +277,8 @@
 
   m_overlapped.hEvent = NULL;
 
-  // Writes are not interruptible like reads are, so just block until it's done.
+  // Writes are not interruptible like reads are, so just block until it's
+  // done.
   result = ::WriteFile(m_file, src, src_len, NULL, &m_overlapped);
   if (!result && ::GetLastError() != ERROR_IO_PENDING) {
     return_info.Set(0, eConnectionStatusError, ::GetLastError());
Index: source/Host/windows/EditLineWin.cpp
===================================================================
--- source/Host/windows/EditLineWin.cpp
+++ source/Host/windows/EditLineWin.cpp
@@ -35,7 +35,8 @@
 // stored key bindings
 static std::vector<el_binding *> _bindings;
 
-// TODO: this should in fact be related to the exact edit line context we create
+// TODO: this should in fact be related to the exact edit line context we
+// create
 static void *clientData = NULL;
 
 // store the current prompt string
@@ -316,8 +317,8 @@
 }
 
 int el_source(EditLine *el, const char *file) {
-  // init edit line by reading the contents of 'file'
-  // nothing to do here on windows...
+  // init edit line by reading the contents of 'file' nothing to do here
+  // on windows...
   return 0;
 }
 
@@ -342,8 +343,8 @@
 }
 
 int history(History *, HistEvent *, int op, ...) {
-  // perform operation 'op' on the history list with
-  // optional arguments as needed by the operation.
+  // perform operation 'op' on the history list with optional arguments as
+  // needed by the operation.
   return 0;
 }
 
Index: source/Host/windows/FileSystem.cpp
===================================================================
--- source/Host/windows/FileSystem.cpp
+++ source/Host/windows/FileSystem.cpp
@@ -65,8 +65,8 @@
   }
 
   std::vector<wchar_t> buf(PATH_MAX + 1);
-  // Subtract 1 from the path length since this function does not add a null
-  // terminator.
+  // Subtract 1 from the path length since this function does not add a
+  // null terminator.
   DWORD result = ::GetFinalPathNameByHandleW(
       h, buf.data(), buf.size() - 1, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
   std::string path;
Index: source/Host/windows/Host.cpp
===================================================================
--- source/Host/windows/Host.cpp
+++ source/Host/windows/Host.cpp
@@ -34,9 +34,8 @@
 
 namespace {
 bool GetTripleForProcess(const FileSpec &executable, llvm::Triple &triple) {
-  // Open the PE File as a binary file, and parse just enough information to
-  // determine the
-  // machine type.
+  // Open the PE File as a binary file, and parse just enough information
+  // to determine the machine type.
   File imageBinary(executable.GetPath().c_str(), File::eOpenOptionRead,
                    lldb::eFilePermissionsUserRead);
   imageBinary.SeekFromStart(0x3c);
@@ -63,8 +62,8 @@
 }
 
 bool GetExecutableForProcess(const AutoHandle &handle, std::string &path) {
-  // Get the process image path.  MAX_PATH isn't long enough, paths can actually
-  // be up to 32KB.
+  // Get the process image path.  MAX_PATH isn't long enough, paths can
+  // actually be up to 32KB.
   std::vector<wchar_t> buffer(PATH_MAX);
   DWORD dwSize = buffer.size();
   if (!::QueryFullProcessImageNameW(handle.get(), 0, &buffer[0], &dwSize))
@@ -74,11 +73,10 @@
 
 void GetProcessExecutableAndTriple(const AutoHandle &handle,
                                    ProcessInstanceInfo &process) {
-  // We may not have permissions to read the path from the process.  So start
-  // off by
-  // setting the executable file to whatever Toolhelp32 gives us, and then try
-  // to
-  // enhance this with more detailed information, but fail gracefully.
+  // We may not have permissions to read the path from the process.  So
+  // start off by setting the executable file to whatever Toolhelp32 gives
+  // us, and then try to enhance this with more detailed information, but
+  // fail gracefully.
   std::string executable;
   llvm::Triple triple;
   triple.setVendor(llvm::Triple::PC);
@@ -171,7 +169,8 @@
   process_info.SetProcessID(pid);
   GetProcessExecutableAndTriple(handle, process_info);
 
-  // Need to read the PEB to get parent process and command line arguments.
+  // Need to read the PEB to get parent process and command line
+  // arguments.
   return true;
 }
 
@@ -260,9 +259,9 @@
 
 Environment Host::GetEnvironment() {
   Environment env;
-  // The environment block on Windows is a contiguous buffer of NULL terminated
-  // strings, where the end of the environment block is indicated by two
-  // consecutive NULLs.
+  // The environment block on Windows is a contiguous buffer of NULL
+  // terminated strings, where the end of the environment block is
+  // indicated by two consecutive NULLs.
   LPWCH environment_block = ::GetEnvironmentStringsW();
   while (*environment_block != L'\0') {
     std::string current_var;
Index: source/Host/windows/HostInfoWindows.cpp
===================================================================
--- source/Host/windows/HostInfoWindows.cpp
+++ source/Host/windows/HostInfoWindows.cpp
@@ -50,11 +50,10 @@
   info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
 #pragma warning(push)
 #pragma warning(disable : 4996)
-  // Starting with Microsoft SDK for Windows 8.1, this function is deprecated in
-  // favor of the
-  // new Windows Version Helper APIs.  Since we don't specify a minimum SDK
-  // version, it's easier
-  // to simply disable the warning rather than try to support both APIs.
+  // Starting with Microsoft SDK for Windows 8.1, this function is
+  // deprecated in favor of the new Windows Version Helper APIs.  Since we
+  // don't specify a minimum SDK version, it's easier to simply disable
+  // the warning rather than try to support both APIs.
   if (GetVersionEx((LPOSVERSIONINFO)&info) == 0) {
     return false;
   }
Index: source/Host/windows/HostProcessWindows.cpp
===================================================================
--- source/Host/windows/HostProcessWindows.cpp
+++ source/Host/windows/HostProcessWindows.cpp
@@ -87,9 +87,9 @@
   MonitorInfo *info = new MonitorInfo;
   info->callback = callback;
 
-  // Since the life of this HostProcessWindows instance and the life of the
-  // process may be different, duplicate the handle so that
-  // the monitor thread can have ownership over its own copy of the handle.
+  // Since the life of this HostProcessWindows instance and the life of
+  // the process may be different, duplicate the handle so that the
+  // monitor thread can have ownership over its own copy of the handle.
   HostThread result;
   if (::DuplicateHandle(GetCurrentProcess(), m_process, GetCurrentProcess(),
                         &info->process_handle, 0, FALSE, DUPLICATE_SAME_ACCESS))
Index: source/Host/windows/PipeWindows.cpp
===================================================================
--- source/Host/windows/PipeWindows.cpp
+++ source/Host/windows/PipeWindows.cpp
@@ -40,11 +40,9 @@
 PipeWindows::~PipeWindows() { Close(); }
 
 Status PipeWindows::CreateNew(bool child_process_inherit) {
-  // Even for anonymous pipes, we open a named pipe.  This is because you cannot
-  // get
-  // overlapped i/o on Windows without using a named pipe.  So we synthesize a
-  // unique
-  // name.
+  // Even for anonymous pipes, we open a named pipe.  This is because you
+  // cannot get overlapped i/o on Windows without using a named pipe.  So
+  // we synthesize a unique name.
   uint32_t serial = g_pipe_serial.fetch_add(1);
   std::string pipe_name;
   llvm::raw_string_ostream pipe_name_stream(pipe_name);
@@ -65,8 +63,8 @@
   std::string pipe_path = "\\\\.\\Pipe\\";
   pipe_path.append(name);
 
-  // Always open for overlapped i/o.  We implement blocking manually in Read and
-  // Write.
+  // Always open for overlapped i/o.  We implement blocking manually in
+  // Read and Write.
   DWORD read_mode = FILE_FLAG_OVERLAPPED;
   m_read = ::CreateNamedPipeA(
       pipe_path.c_str(), PIPE_ACCESS_INBOUND | read_mode,
@@ -249,14 +247,12 @@
                       : duration.count() * 1000;
   DWORD wait_result = ::WaitForSingleObject(m_read_overlapped.hEvent, timeout);
   if (wait_result != WAIT_OBJECT_0) {
-    // The operation probably failed.  However, if it timed out, we need to
-    // cancel the I/O.
-    // Between the time we returned from WaitForSingleObject and the time we
-    // call CancelIoEx,
-    // the operation may complete.  If that hapens, CancelIoEx will fail and
-    // return ERROR_NOT_FOUND.
-    // If that happens, the original operation should be considered to have been
-    // successful.
+    // The operation probably failed.  However, if it timed out, we need
+    // to cancel the I/O. Between the time we returned from
+    // WaitForSingleObject and the time we call CancelIoEx, the operation
+    // may complete.  If that hapens, CancelIoEx will fail and return
+    // ERROR_NOT_FOUND. If that happens, the original operation should be
+    // considered to have been successful.
     bool failed = true;
     DWORD failure_error = ::GetLastError();
     if (wait_result == WAIT_TIMEOUT) {
@@ -268,9 +264,8 @@
       return Status(failure_error, eErrorTypeWin32);
   }
 
-  // Now we call GetOverlappedResult setting bWait to false, since we've already
-  // waited
-  // as long as we're willing to.
+  // Now we call GetOverlappedResult setting bWait to false, since we've
+  // already waited as long as we're willing to.
   if (!GetOverlappedResult(m_read, &m_read_overlapped, &sys_bytes_read, FALSE))
     return Status(::GetLastError(), eErrorTypeWin32);
 
Index: source/Host/windows/ProcessLauncherWindows.cpp
===================================================================
--- source/Host/windows/ProcessLauncherWindows.cpp
+++ source/Host/windows/ProcessLauncherWindows.cpp
@@ -26,7 +26,8 @@
   if (env.size() == 0)
     return;
 
-  // Environment buffer is a null terminated list of null terminated strings
+  // Environment buffer is a null terminated list of null terminated
+  // strings
   for (const auto &KV : env) {
     std::wstring warg;
     if (llvm::ConvertUTF8toWide(Environment::compose(KV), warg)) {
@@ -97,8 +98,8 @@
       wworkingDirectory.size() == 0 ? NULL : wworkingDirectory.c_str(),
       &startupinfo, &pi);
   if (result) {
-    // Do not call CloseHandle on pi.hProcess, since we want to pass that back
-    // through the HostProcess.
+    // Do not call CloseHandle on pi.hProcess, since we want to pass that
+    // back through the HostProcess.
     ::CloseHandle(pi.hThread);
   }
 
Index: source/Initialization/SystemInitializerCommon.cpp
===================================================================
--- source/Initialization/SystemInitializerCommon.cpp
+++ source/Initialization/SystemInitializerCommon.cpp
@@ -51,12 +51,10 @@
   const char *disable_crash_dialog_var = getenv("LLDB_DISABLE_CRASH_DIALOG");
   if (disable_crash_dialog_var &&
       llvm::StringRef(disable_crash_dialog_var).equals_lower("true")) {
-    // This will prevent Windows from displaying a dialog box requiring user
-    // interaction when
-    // LLDB crashes.  This is mostly useful when automating LLDB, for example
-    // via the test
-    // suite, so that a crash in LLDB does not prevent completion of the test
-    // suite.
+    // This will prevent Windows from displaying a dialog box requiring
+    // user interaction when LLDB crashes.  This is mostly useful when
+    // automating LLDB, for example via the test suite, so that a crash in
+    // LLDB does not prevent completion of the test suite.
     ::SetErrorMode(GetErrorMode() | SEM_FAILCRITICALERRORS |
                    SEM_NOGPFAULTERRORBOX);
 
Index: source/Interpreter/CommandAlias.cpp
===================================================================
--- source/Interpreter/CommandAlias.cpp
+++ source/Interpreter/CommandAlias.cpp
@@ -32,11 +32,12 @@
   Args args(options_args);
   std::string options_string(options_args);
   CommandReturnObject result;
-  // Check to see if the command being aliased can take any command options.
+  // Check to see if the command being aliased can take any command
+  // options.
   Options *options = cmd_obj_sp->GetOptions();
   if (options) {
-    // See if any options were specified as part of the alias;  if so, handle
-    // them appropriately.
+    // See if any options were specified as part of the alias;  if so,
+    // handle them appropriately.
     ExecutionContext exe_ctx =
         cmd_obj_sp->GetCommandInterpreter().GetExecutionContext();
     options->NotifyOptionParsingStarting(&exe_ctx);
@@ -227,9 +228,9 @@
   return {underlying, GetOptionArguments()};
 }
 
-// allow CommandAlias objects to provide their own help, but fallback to the
-// info
-// for the underlying command if no customization has been provided
+// allow CommandAlias objects to provide their own help, but fallback to
+// the info for the underlying command if no customization has been
+// provided
 void CommandAlias::SetHelp(llvm::StringRef str) {
   this->CommandObject::SetHelp(str);
   m_did_set_help = true;
Index: source/Interpreter/CommandInterpreter.cpp
===================================================================
--- source/Interpreter/CommandInterpreter.cpp
+++ source/Interpreter/CommandInterpreter.cpp
@@ -539,8 +539,8 @@
   if (tbreak_regex_cmd_ap.get()) {
     bool success = true;
     for (size_t i = 0; i < num_regexes; i++) {
-      // If you add a resultant command string longer than 1024 characters be
-      // sure to increase the size of this buffer.
+      // If you add a resultant command string longer than 1024 characters
+      // be sure to increase the size of this buffer.
       char buffer[1024];
       int num_printed =
           snprintf(buffer, 1024, "%s %s", break_regexes[i][1], "-o");
@@ -681,10 +681,9 @@
           "bt [<digit> | all]", 2, 0, false));
   if (bt_regex_cmd_ap.get()) {
     // accept but don't document "bt -c <number>" -- before bt was a regex
-    // command if you wanted to backtrace
-    // three frames you would do "bt -c 3" but the intention is to have this
-    // emulate the gdb "bt" command and
-    // so now "bt 3" is the preferred form, in line with gdb.
+    // command if you wanted to backtrace three frames you would do "bt -c
+    // 3" but the intention is to have this emulate the gdb "bt" command
+    // and so now "bt 3" is the preferred form, in line with gdb.
     if (bt_regex_cmd_ap->AddRegexCommand("^([[:digit:]]+)$",
                                          "thread backtrace -c %1") &&
         bt_regex_cmd_ap->AddRegexCommand("^-c ([[:digit:]]+)$",
@@ -824,10 +823,9 @@
     unsigned int num_alias_matches = 0;
     unsigned int num_user_matches = 0;
 
-    // Look through the command dictionaries one by one, and if we get only one
-    // match from any of
-    // them in toto, then return that, otherwise return an empty CommandObjectSP
-    // and the list of matches.
+    // Look through the command dictionaries one by one, and if we get
+    // only one match from any of them in toto, then return that,
+    // otherwise return an empty CommandObjectSP and the list of matches.
 
     if (HasCommands()) {
       num_cmd_matches =
@@ -867,8 +865,8 @@
         user_match_sp = pos->second;
     }
 
-    // If we got exactly one match, return that, otherwise return the match
-    // list.
+    // If we got exactly one match, return that, otherwise return the
+    // match list.
 
     if (num_user_matches + num_cmd_matches + num_alias_matches == 1) {
       if (num_cmd_matches)
@@ -948,32 +946,31 @@
   if (cmd_words.GetArgumentCount() == 1)
     return GetCommandSP(cmd_str, include_aliases, true, nullptr);
   else {
-    // We have a multi-word command (seemingly), so we need to do more work.
-    // First, get the cmd_obj_sp for the first word in the command.
+    // We have a multi-word command (seemingly), so we need to do more
+    // work. First, get the cmd_obj_sp for the first word in the command.
     CommandObjectSP cmd_obj_sp = GetCommandSP(llvm::StringRef(cmd_words.GetArgumentAtIndex(0)),
                                               include_aliases, true, nullptr);
     if (cmd_obj_sp.get() != nullptr) {
-      // Loop through the rest of the words in the command (everything passed in
-      // was supposed to be part of a
-      // command name), and find the appropriate sub-command SP for each command
-      // word....
+      // Loop through the rest of the words in the command (everything
+      // passed in was supposed to be part of a command name), and find
+      // the appropriate sub-command SP for each command word....
       size_t end = cmd_words.GetArgumentCount();
       for (size_t j = 1; j < end; ++j) {
         if (cmd_obj_sp->IsMultiwordObject()) {
           cmd_obj_sp =
               cmd_obj_sp->GetSubcommandSP(cmd_words.GetArgumentAtIndex(j));
           if (cmd_obj_sp.get() == nullptr)
-            // The sub-command name was invalid.  Fail and return the empty
-            // 'ret_val'.
+            // The sub-command name was invalid.  Fail and return the
+            // empty 'ret_val'.
             return ret_val;
         } else
           // We have more words in the command name, but we don't have a
           // multiword object. Fail and return empty 'ret_val'.
           return ret_val;
       }
-      // We successfully looped through all the command words and got valid
-      // command objects for them.  Assign the last object retrieved to
-      // 'ret_val'.
+      // We successfully looped through all the command words and got
+      // valid command objects for them.  Assign the last object retrieved
+      // to 'ret_val'.
       ret_val = cmd_obj_sp;
     }
   }
@@ -985,9 +982,8 @@
   CommandObject *command_obj =
       GetCommandSP(cmd_str, false, true, matches).get();
 
-  // If we didn't find an exact match to the command string in the commands,
-  // look in
-  // the aliases.
+  // If we didn't find an exact match to the command string in the
+  // commands, look in the aliases.
 
   if (command_obj)
     return command_obj;
@@ -997,13 +993,12 @@
   if (command_obj)
     return command_obj;
 
-  // If there wasn't an exact match then look for an inexact one in just the
-  // commands
+  // If there wasn't an exact match then look for an inexact one in just
+  // the commands
   command_obj = GetCommandSP(cmd_str, false, false, nullptr).get();
 
-  // Finally, if there wasn't an inexact match among the commands, look for an
-  // inexact
-  // match in both the commands and aliases.
+  // Finally, if there wasn't an inexact match among the commands, look
+  // for an inexact match in both the commands and aliases.
 
   if (command_obj) {
     if (matches)
@@ -1030,7 +1025,8 @@
     num_alias_matches =
         AddNamesMatchingPartialString(m_alias_dict, cmd, matches);
     if (num_alias_matches == 1) {
-      // Make sure this isn't shadowing a command in the regular command space:
+      // Make sure this isn't shadowing a command in the regular command
+      // space:
       StringList regular_matches;
       const bool include_aliases = false;
       const bool exact = false;
@@ -1165,9 +1161,9 @@
 
 CommandObject *CommandInterpreter::GetCommandObjectForCommand(
     llvm::StringRef &command_string) {
-  // This function finds the final, lowest-level, alias-resolved command object
-  // whose 'Execute' function will
-  // eventually be invoked by the given command line.
+  // This function finds the final, lowest-level, alias-resolved command
+  // object whose 'Execute' function will eventually be invoked by the
+  // given command line.
 
   CommandObject *cmd_obj = nullptr;
   size_t start = command_string.find_first_not_of(k_white_space);
@@ -1182,12 +1178,12 @@
       std::string cmd_word = command_string.substr(start, end - start);
 
       if (cmd_obj == nullptr)
-        // Since cmd_obj is NULL we are on our first time through this loop.
-        // Check to see if cmd_word is a valid command or alias.
+        // Since cmd_obj is NULL we are on our first time through this
+        // loop. Check to see if cmd_word is a valid command or alias.
         cmd_obj = GetCommandObject(cmd_word);
       else if (cmd_obj->IsMultiwordObject()) {
-        // Our current object is a multi-word object; see if the cmd_word is a
-        // valid sub-command for our object.
+        // Our current object is a multi-word object; see if the cmd_word
+        // is a valid sub-command for our object.
         CommandObject *sub_cmd_obj =
             cmd_obj->GetSubcommandObject(cmd_word.c_str());
         if (sub_cmd_obj)
@@ -1195,12 +1191,14 @@
         else // cmd_word was not a valid sub-command word, so we are done
           done = true;
       } else
-        // We have a cmd_obj and it is not a multi-word object, so we are done.
+        // We have a cmd_obj and it is not a multi-word object, so we are
+        // done.
         done = true;
 
-      // If we didn't find a valid command object, or our command object is not
-      // a multi-word object, or we are at the end of the command_string, then
-      // we are done.  Otherwise, find the start of the next word.
+      // If we didn't find a valid command object, or our command object
+      // is not a multi-word object, or we are at the end of the
+      // command_string, then we are done.  Otherwise, find the start of
+      // the next word.
 
       if (!cmd_obj || !cmd_obj->IsMultiwordObject() ||
           end >= command_string.size())
@@ -1374,13 +1372,12 @@
 }
 
 Status CommandInterpreter::PreprocessCommand(std::string &command) {
-  // The command preprocessor needs to do things to the command
-  // line before any parsing of arguments or anything else is done.
-  // The only current stuff that gets preprocessed is anything enclosed
-  // in backtick ('`') characters is evaluated as an expression and
-  // the result of the expression must be a scalar that can be substituted
-  // into the command. An example would be:
-  // (lldb) memory read `$rsp + 20`
+  // The command preprocessor needs to do things to the command line
+  // before any parsing of arguments or anything else is done. The only
+  // current stuff that gets preprocessed is anything enclosed in backtick
+  // ('`') characters is evaluated as an expression and the result of the
+  // expression must be a scalar that can be substituted into the command.
+  // An example would be: (lldb) memory read `$rsp + 20`
   Status error; // Status for any expressions that might not evaluate
   size_t start_backtick;
   size_t pos = 0;
@@ -1405,9 +1402,9 @@
 
         ExecutionContext exe_ctx(GetExecutionContext());
         Target *target = exe_ctx.GetTargetPtr();
-        // Get a dummy target to allow for calculator mode while processing
-        // backticks.
-        // This also helps break the infinite loop caused when target is null.
+        // Get a dummy target to allow for calculator mode while
+        // processing backticks. This also helps break the infinite loop
+        // caused when target is null.
         if (!target)
           target = m_debugger.GetDummyTarget();
         if (target) {
@@ -1559,8 +1556,8 @@
     const char *k_space_characters = "\t\n\v\f\r ";
 
     size_t non_space = command_string.find_first_not_of(k_space_characters);
-    // Check for empty line or comment line (lines whose first
-    // non-space character is the comment character for this interpreter)
+    // Check for empty line or comment line (lines whose first non-space
+    // character is the comment character for this interpreter)
     if (non_space == std::string::npos)
       empty_command = true;
     else if (command_string[non_space] == m_comment_char)
@@ -1617,13 +1614,13 @@
 
   // Phase 1.
 
-  // Before we do ANY kind of argument processing, we need to figure out what
-  // the real/final command object is for the specified command.  This gets
-  // complicated by the fact that the user could have specified an alias, and,
-  // in translating the alias, there may also be command options and/or even
-  // data (including raw text strings) that need to be found and inserted into
-  // the command line as part of the translation.  So this first step is plain
-  // look-up and replacement, resulting in:
+  // Before we do ANY kind of argument processing, we need to figure out
+  // what the real/final command object is for the specified command.
+  // This gets complicated by the fact that the user could have specified
+  // an alias, and, in translating the alias, there may also be command
+  // options and/or even data (including raw text strings) that need to be
+  // found and inserted into the command line as part of the translation.
+  // So this first step is plain look-up and replacement, resulting in:
   //    1. the command object whose Execute method will actually be called
   //    2. a revised command string, with all substitutions and replacements
   //       taken care of
@@ -1632,9 +1629,10 @@
 
   CommandObject *cmd_obj = ResolveCommandImpl(command_string, result);
 
-  // Although the user may have abbreviated the command, the command_string now
-  // has the command expanded to the full name.  For example, if the input
-  // was "br s -n main", command_string is now "breakpoint set -n main".
+  // Although the user may have abbreviated the command, the
+  // command_string now has the command expanded to the full name.  For
+  // example, if the input was "br s -n main", command_string is now
+  // "breakpoint set -n main".
   if (log) {
     llvm::StringRef command_name = cmd_obj ? cmd_obj->GetCommandName() : "<not found>";
     log->Printf("HandleCommand, cmd_obj : '%s'", command_name.str().c_str());
@@ -1648,8 +1646,8 @@
 
   // Phase 2.
   // Take care of things like setting up the history command & calling the
-  // appropriate Execute method on the
-  // CommandObject, with the appropriate arguments.
+  // appropriate Execute method on the CommandObject, with the appropriate
+  // arguments.
 
   if (cmd_obj != nullptr) {
     if (add_to_history) {
@@ -1680,7 +1678,8 @@
 
     cmd_obj->Execute(remainder.c_str(), result);
   } else {
-    // We didn't find the first command object, so complete the first argument.
+    // We didn't find the first command object, so complete the first
+    // argument.
     Args command_args(command_string);
     StringList matches;
     int num_matches;
@@ -1725,7 +1724,8 @@
   int num_command_matches = 0;
   bool look_for_subcommand = false;
 
-  // For any of the command completions a unique match will be a complete word.
+  // For any of the command completions a unique match will be a complete
+  // word.
   word_complete = true;
 
   if (cursor_index == -1) {
@@ -1759,9 +1759,8 @@
 
   if (cursor_index > 0 || look_for_subcommand) {
     // We are completing further on into a commands arguments, so find the
-    // command and tell it
-    // to complete the command.
-    // First see if there is a matching initial command:
+    // command and tell it to complete the command. First see if there is
+    // a matching initial command:
     CommandObject *command_object =
         GetCommandObject(parsed_line.GetArgumentAtIndex(0));
     if (command_object == nullptr) {
@@ -1781,17 +1780,17 @@
 int CommandInterpreter::HandleCompletion(
     const char *current_line, const char *cursor, const char *last_char,
     int match_start_point, int max_return_elements, StringList &matches) {
-  // We parse the argument up to the cursor, so the last argument in parsed_line
-  // is
-  // the one containing the cursor, and the cursor is after the last character.
+  // We parse the argument up to the cursor, so the last argument in
+  // parsed_line is the one containing the cursor, and the cursor is after
+  // the last character.
 
   Args parsed_line(llvm::StringRef(current_line, last_char - current_line));
   Args partial_parsed_line(
       llvm::StringRef(current_line, cursor - current_line));
 
-  // Don't complete comments, and if the line we are completing is just the
-  // history repeat character,
-  // substitute the appropriate history line.
+  // Don't complete comments, and if the line we are completing is just
+  // the history repeat character, substitute the appropriate history
+  // line.
   const char *first_arg = parsed_line.GetArgumentAtIndex(0);
   if (first_arg) {
     if (first_arg[0] == m_comment_char)
@@ -1818,13 +1817,10 @@
 
   if (cursor > current_line && cursor[-1] == ' ') {
     // We are just after a space.  If we are in an argument, then we will
-    // continue
-    // parsing, but if we are between arguments, then we have to complete
-    // whatever the next
-    // element would be.
-    // We can distinguish the two cases because if we are in an argument (e.g.
-    // because the space is
-    // protected by a quote) then the space will also be in the parsed
+    // continue parsing, but if we are between arguments, then we have to
+    // complete whatever the next element would be. We can distinguish the
+    // two cases because if we are in an argument (e.g. because the space
+    // is protected by a quote) then the space will also be in the parsed
     // argument...
 
     const char *current_elem =
@@ -1856,9 +1852,8 @@
     // If we got an empty string, insert nothing.
     matches.InsertStringAtIndex(0, "");
   } else {
-    // Now figure out if there is a common substring, and if so put that in
-    // element 0, otherwise
-    // put an empty string in element 0.
+    // Now figure out if there is a common substring, and if so put that
+    // in element 0, otherwise put an empty string in element 0.
     std::string command_partial_str;
     if (cursor_index >= 0)
       command_partial_str =
@@ -1869,9 +1864,8 @@
     const size_t partial_name_len = command_partial_str.size();
     common_prefix.erase(0, partial_name_len);
 
-    // If we matched a unique single command, add a space...
-    // Only do this if the completer told us this was a complete word,
-    // however...
+    // If we matched a unique single command, add a space... Only do this
+    // if the completer told us this was a complete word, however...
     if (num_command_matches == 1 && word_complete) {
       char quote_char = parsed_line[cursor_index].quote;
       common_prefix =
@@ -1948,12 +1942,13 @@
 
   if (option_arg_vector_sp.get()) {
     if (wants_raw_input) {
-      // We have a command that both has command options and takes raw input.
-      // Make *sure* it has a
-      // " -- " in the right place in the raw_input_string.
+      // We have a command that both has command options and takes raw
+      // input. Make *sure* it has a " -- " in the right place in the
+      // raw_input_string.
       size_t pos = raw_input_string.find(" -- ");
       if (pos == std::string::npos) {
-        // None found; assume it goes at the beginning of the raw input string
+        // None found; assume it goes at the beginning of the raw input
+        // string
         raw_input_string.insert(0, " -- ");
       }
     }
@@ -1971,7 +1966,8 @@
       std::tie(option, value_type, value) = option_entry;
       if (option == "<argument>") {
         if (!wants_raw_input || (value != "--")) {
-          // Since we inserted this above, make sure we don't insert it twice
+          // Since we inserted this above, make sure we don't insert it
+          // twice
           new_args.AppendArgument(value);
         }
         continue;
@@ -2003,7 +1999,8 @@
         result.SetStatus(eReturnStatusFailed);
         return;
       } else {
-        // Find and remove cmd_args.GetArgumentAtIndex(i) from raw_input_string
+        // Find and remove cmd_args.GetArgumentAtIndex(i) from
+        // raw_input_string
         size_t strpos =
             raw_input_string.find(cmd_args.GetArgumentAtIndex(index));
         if (strpos != std::string::npos) {
@@ -2033,11 +2030,10 @@
                           new_args.GetConstArgumentVector());
   } else {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
-    // This alias was not created with any options; nothing further needs to be
-    // done, unless it is a command that
-    // wants raw input, in which case we need to clear the rest of the data from
-    // cmd_args, since its in the raw
-    // input string.
+    // This alias was not created with any options; nothing further needs
+    // to be done, unless it is a command that wants raw input, in which
+    // case we need to clear the rest of the data from cmd_args, since its
+    // in the raw input string.
     if (wants_raw_input) {
       cmd_args.Clear();
       cmd_args.SetArguments(new_args.GetArgumentCount(),
@@ -2067,7 +2063,8 @@
       while (isdigit(cptr[0]))
         ++cptr;
 
-      // We've gotten to the end of the digits; are we at the end of the string?
+      // We've gotten to the end of the digits; are we at the end of the
+      // string?
       if (cptr[0] == '\0')
         position = atoi(start);
     }
@@ -2083,8 +2080,8 @@
     ExecutionContext exe_ctx(GetExecutionContext());
     Target *target = exe_ctx.GetTargetPtr();
     if (target) {
-      // In the current working directory we don't load any program specific
-      // .lldbinit files, we only look for a ".lldbinit" file.
+      // In the current working directory we don't load any program
+      // specific .lldbinit files, we only look for a ".lldbinit" file.
       if (m_skip_lldbinit_files)
         return;
 
@@ -2119,12 +2116,12 @@
       }
     }
   } else {
-    // If we aren't looking in the current working directory we are looking
-    // in the home directory. We will first see if there is an application
-    // specific ".lldbinit" file whose name is "~/.lldbinit" followed by a
-    // "-" and the name of the program. If this file doesn't exist, we fall
-    // back to just the "~/.lldbinit" file. We also obey any requests to not
-    // load the init files.
+    // If we aren't looking in the current working directory we are
+    // looking in the home directory. We will first see if there is an
+    // application specific ".lldbinit" file whose name is "~/.lldbinit"
+    // followed by a "-" and the name of the program. If this file doesn't
+    // exist, we fall back to just the "~/.lldbinit" file. We also obey
+    // any requests to not load the init files.
     llvm::SmallString<64> home_dir_path;
     llvm::sys::path::home_directory(home_dir_path);
     FileSpec profilePath(home_dir_path.c_str(), false);
@@ -2149,10 +2146,9 @@
       init_file.SetFile(init_file_path, false);
   }
 
-  // If the file exists, tell HandleCommand to 'source' it; this will do the
-  // actual broadcasting
-  // of the commands back to any appropriate listener (see
-  // CommandObjectSource::Execute for more details).
+  // If the file exists, tell HandleCommand to 'source' it; this will do
+  // the actual broadcasting of the commands back to any appropriate
+  // listener (see CommandObjectSource::Execute for more details).
 
   if (init_file.Exists()) {
     const bool saved_batch = SetBatchCommandMode(true);
@@ -2197,15 +2193,15 @@
   size_t num_lines = commands.GetSize();
 
   // If we are going to continue past a "continue" then we need to run the
-  // commands synchronously.
-  // Make sure you reset this value anywhere you return from the function.
+  // commands synchronously. Make sure you reset this value anywhere you
+  // return from the function.
 
   bool old_async_execution = m_debugger.GetAsyncExecution();
 
-  // If we've been given an execution context, set it at the start, but don't
-  // keep resetting it or we will
-  // cause series of commands that change the context, then do an operation that
-  // relies on that context to fail.
+  // If we've been given an execution context, set it at the start, but
+  // don't keep resetting it or we will cause series of commands that
+  // change the context, then do an operation that relies on that context
+  // to fail.
 
   if (override_context != nullptr)
     UpdateExecutionContext(override_context);
@@ -2226,13 +2222,13 @@
     }
 
     CommandReturnObject tmp_result;
-    // If override_context is not NULL, pass no_context_switching = true for
-    // HandleCommand() since we updated our context already.
+    // If override_context is not NULL, pass no_context_switching = true
+    // for HandleCommand() since we updated our context already.
 
     // We might call into a regex or alias command, in which case the
-    // add_to_history will get lost.  This
-    // m_command_source_depth dingus is the way we turn off adding to the
-    // history in that case, so set it up here.
+    // add_to_history will get lost.  This m_command_source_depth dingus
+    // is the way we turn off adding to the history in that case, so set
+    // it up here.
     if (!options.GetAddToHistory())
       m_command_source_depth++;
     bool success =
@@ -2273,18 +2269,17 @@
     if (result.GetImmediateErrorStream())
       result.GetImmediateErrorStream()->Flush();
 
-    // N.B. Can't depend on DidChangeProcessState, because the state coming into
-    // the command execution
-    // could be running (for instance in Breakpoint Commands.
-    // So we check the return value to see if it is has running in it.
+    // N.B. Can't depend on DidChangeProcessState, because the state
+    // coming into the command execution could be running (for instance in
+    // Breakpoint Commands. So we check the return value to see if it is
+    // has running in it.
     if ((tmp_result.GetStatus() == eReturnStatusSuccessContinuingNoResult) ||
         (tmp_result.GetStatus() == eReturnStatusSuccessContinuingResult)) {
       if (options.GetStopOnContinue()) {
-        // If we caused the target to proceed, and we're going to stop in that
-        // case, set the
-        // status in our real result before returning.  This is an error if the
-        // continue was not the
-        // last command in the set of commands to be run.
+        // If we caused the target to proceed, and we're going to stop in
+        // that case, set the status in our real result before returning.
+        // This is an error if the continue was not the last command in
+        // the set of commands to be run.
         if (idx != num_lines - 1)
           result.AppendErrorWithFormat(
               "Aborting reading of commands after command #%" PRIu64
@@ -2344,8 +2339,8 @@
   return;
 }
 
-// Make flags that we can pass into the IOHandler so our delegates can do the
-// right thing
+// Make flags that we can pass into the IOHandler so our delegates can do
+// the right thing
 enum {
   eHandleCommandFlagStopOnContinue = (1u << 0),
   eHandleCommandFlagStopOnError = (1u << 1),
@@ -2432,8 +2427,8 @@
                                          cmd_file_path.c_str());
       }
 
-      // Used for inheriting the right settings when "command source" might have
-      // nested "command source" commands
+      // Used for inheriting the right settings when "command source"
+      // might have nested "command source" commands
       lldb::StreamFileSP empty_stream_sp;
       m_command_source_flags.push_back(flags);
       IOHandlerSP io_handler_sp(new IOHandlerEditline(
@@ -2521,7 +2516,8 @@
     // Always break on an explicit newline.
     std::size_t first_newline = this_line.find_first_of("\n");
 
-    // Don't break on space/tab unless the text is too long to fit on one line.
+    // Don't break on space/tab unless the text is too long to fit on one
+    // line.
     std::size_t last_space = llvm::StringRef::npos;
     if (this_line.size() != help_text.size())
       last_space = this_line.find_last_of(" \t");
@@ -2744,20 +2740,17 @@
 
   const bool is_interactive = io_handler.GetIsInteractive();
   if (is_interactive == false) {
-    // When we are not interactive, don't execute blank lines. This will happen
-    // sourcing a commands file. We don't want blank lines to repeat the
-    // previous
-    // command and cause any errors to occur (like redefining an alias, get an
-    // error
-    // and stop parsing the commands file).
+    // When we are not interactive, don't execute blank lines. This will
+    // happen sourcing a commands file. We don't want blank lines to
+    // repeat the previous command and cause any errors to occur (like
+    // redefining an alias, get an error and stop parsing the commands
+    // file).
     if (line.empty())
       return;
 
-    // When using a non-interactive file handle (like when sourcing commands
-    // from a file)
-    // we need to echo the command out so we don't just see the command output
-    // and no
-    // command...
+    // When using a non-interactive file handle (like when sourcing
+    // commands from a file) we need to echo the command out so we don't
+    // just see the command output and no command...
     if (io_handler.GetFlags().Test(eHandleCommandFlagEchoCommand))
       io_handler.GetOutputStreamFile()->Printf("%s%s\n", io_handler.GetPrompt(),
                                                line.c_str());
@@ -2770,7 +2763,8 @@
 
   // Now emit the command output text from the command we just executed
   if (io_handler.GetFlags().Test(eHandleCommandFlagPrintResult)) {
-    // Display any STDOUT/STDERR _prior_ to emitting the command result text
+    // Display any STDOUT/STDERR _prior_ to emitting the command result
+    // text
     GetProcessOutput();
 
     if (!result.GetImmediateOutputStream()) {
@@ -2914,13 +2908,13 @@
 lldb::IOHandlerSP
 CommandInterpreter::GetIOHandler(bool force_create,
                                  CommandInterpreterRunOptions *options) {
-  // Always re-create the IOHandlerEditline in case the input
-  // changed. The old instance might have had a non-interactive
-  // input and now it does or vice versa.
+  // Always re-create the IOHandlerEditline in case the input changed. The
+  // old instance might have had a non-interactive input and now it does
+  // or vice versa.
   if (force_create || !m_command_io_handler_sp) {
-    // Always re-create the IOHandlerEditline in case the input
-    // changed. The old instance might have had a non-interactive
-    // input and now it does or vice versa.
+    // Always re-create the IOHandlerEditline in case the input changed.
+    // The old instance might have had a non-interactive input and now it
+    // does or vice versa.
     uint32_t flags = 0;
 
     if (options) {
@@ -2954,8 +2948,8 @@
 void CommandInterpreter::RunCommandInterpreter(
     bool auto_handle_events, bool spawn_thread,
     CommandInterpreterRunOptions &options) {
-  // Always re-create the command interpreter when we run it in case
-  // any file handles have changed.
+  // Always re-create the command interpreter when we run it in case any
+  // file handles have changed.
   bool force_create = true;
   m_debugger.PushIOHandler(GetIOHandler(force_create, &options));
   m_stopped_for_crash = false;
@@ -3023,8 +3017,8 @@
         CommandObject *sub_cmd_obj =
             cmd_obj->GetSubcommandObject(next_word.c_str());
         if (sub_cmd_obj) {
-          // The subcommand's name includes the parent command's name,
-          // so restart rather than append to the revised_command_line.
+          // The subcommand's name includes the parent command's name, so
+          // restart rather than append to the revised_command_line.
           llvm::StringRef sub_cmd_name = sub_cmd_obj->GetCommandName();
           actual_cmd_name_len = sub_cmd_name.size() + 1;
           revised_command_line.Clear();
@@ -3102,8 +3096,8 @@
               std::string cmd = revised_command_line.GetString();
               size_t arg_terminator_idx = FindArgumentTerminator(cmd);
               if (arg_terminator_idx != std::string::npos) {
-                // Insert the gdb format option before the "--" that terminates
-                // options
+                // Insert the gdb format option before the "--" that
+                // terminates options
                 gdb_format_option.append(1, ' ');
                 cmd.insert(arg_terminator_idx, gdb_format_option);
                 revised_command_line.Clear();
Index: source/Interpreter/CommandObject.cpp
===================================================================
--- source/Interpreter/CommandObject.cpp
+++ source/Interpreter/CommandObject.cpp
@@ -20,8 +20,8 @@
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Utility/ArchSpec.h"
 
-// These are for the Sourcename completers.
-// FIXME: Make a separate file for the completers.
+// These are for the Sourcename completers. FIXME: Make a separate file
+// for the completers.
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Target/Process.h"
@@ -138,11 +138,11 @@
 
 bool CommandObject::CheckRequirements(CommandReturnObject &result) {
 #ifdef LLDB_CONFIGURATION_DEBUG
-  // Nothing should be stored in m_exe_ctx between running commands as m_exe_ctx
-  // has shared pointers to the target, process, thread and frame and we don't
-  // want any CommandObject instances to keep any of these objects around
-  // longer than for a single command. Every command should call
-  // CommandObject::Cleanup() after it has completed
+  // Nothing should be stored in m_exe_ctx between running commands as
+  // m_exe_ctx has shared pointers to the target, process, thread and
+  // frame and we don't want any CommandObject instances to keep any of
+  // these objects around longer than for a single command. Every command
+  // should call CommandObject::Cleanup() after it has completed
   assert(m_exe_ctx.GetTargetPtr() == NULL);
   assert(m_exe_ctx.GetProcessPtr() == NULL);
   assert(m_exe_ctx.GetThreadPtr() == NULL);
@@ -150,8 +150,8 @@
 #endif
 
   // Lock down the interpreter's execution context prior to running the
-  // command so we guarantee the selected target, process, thread and frame
-  // can't go away during the execution
+  // command so we guarantee the selected target, process, thread and
+  // frame can't go away during the execution
   m_exe_ctx = m_interpreter.GetExecutionContext();
 
   const uint32_t flags = GetFlags().Get();
@@ -265,10 +265,10 @@
                                     int match_start_point,
                                     int max_return_elements,
                                     bool &word_complete, StringList &matches) {
-  // Default implementation of WantsCompletion() is !WantsRawCommandString().
-  // Subclasses who want raw command string but desire, for example,
-  // argument completion should override WantsCompletion() to return true,
-  // instead.
+  // Default implementation of WantsCompletion() is
+  // !WantsRawCommandString(). Subclasses who want raw command string but
+  // desire, for example, argument completion should override
+  // WantsCompletion() to return true, instead.
   if (WantsRawCommandString() && !WantsCompletion()) {
     // FIXME: Abstract telling the completion to insert the completion
     // character.
@@ -292,7 +292,8 @@
         return matches.GetSize();
     }
 
-    // If we got here, the last word is not an option or an option argument.
+    // If we got here, the last word is not an option or an option
+    // argument.
     return HandleArgumentCompletion(
         input, cursor_index, cursor_char_position, opt_element_vector,
         match_start_point, max_return_elements, word_complete, matches);
@@ -360,8 +361,8 @@
   const ArgumentTableEntry *table = CommandObject::GetArgumentTable();
   const ArgumentTableEntry *entry = &(table[arg_type]);
 
-  // The table is *supposed* to be kept in arg_type order, but someone *could*
-  // have messed it up...
+  // The table is *supposed* to be kept in arg_type order, but someone
+  // *could* have messed it up...
 
   if (entry->arg_type != arg_type)
     entry = CommandObject::FindArgumentDataByType(arg_type);
@@ -390,8 +391,8 @@
   const ArgumentTableEntry *entry =
       &(CommandObject::GetArgumentTable()[arg_type]);
 
-  // The table is *supposed* to be kept in arg_type order, but someone *could*
-  // have messed it up...
+  // The table is *supposed* to be kept in arg_type order, but someone
+  // *could* have messed it up...
 
   if (entry->arg_type != arg_type)
     entry = CommandObject::FindArgumentDataByType(arg_type);
@@ -424,9 +425,10 @@
   return ret_val;
 }
 
-// Default parameter value of opt_set_mask is LLDB_OPT_SET_ALL, which means take
-// all the argument data into account.  On rare cases where some argument sticks
-// with certain option sets, this function returns the option set filtered args.
+// Default parameter value of opt_set_mask is LLDB_OPT_SET_ALL, which
+// means take all the argument data into account.  On rare cases where
+// some argument sticks with certain option sets, this function returns
+// the option set filtered args.
 void CommandObject::GetFormattedCommandArguments(Stream &str,
                                                  uint32_t opt_set_mask) {
   int num_args = m_arguments.size();
@@ -465,16 +467,15 @@
         str.Printf("[<%s_1> <%s_1> ... <%s_n> <%s_n>]", first_name, second_name,
                    first_name, second_name);
         break;
-      // Explicitly test for all the rest of the cases, so if new types get
-      // added we will notice the
-      // missing case statement(s).
+      // Explicitly test for all the rest of the cases, so if new types
+      // get added we will notice the missing case statement(s).
       case eArgRepeatPlain:
       case eArgRepeatOptional:
       case eArgRepeatPlus:
       case eArgRepeatStar:
       case eArgRepeatRange:
-        // These should not be reached, as they should fail the IsPairType test
-        // above.
+        // These should not be reached, as they should fail the IsPairType
+        // test above.
         break;
       }
     } else {
@@ -502,18 +503,17 @@
       case eArgRepeatRange:
         str.Printf("<%s_1> .. <%s_n>", name_str.c_str(), name_str.c_str());
         break;
-      // Explicitly test for all the rest of the cases, so if new types get
-      // added we will notice the
-      // missing case statement(s).
+      // Explicitly test for all the rest of the cases, so if new types
+      // get added we will notice the missing case statement(s).
       case eArgRepeatPairPlain:
       case eArgRepeatPairOptional:
       case eArgRepeatPairPlus:
       case eArgRepeatPairStar:
       case eArgRepeatPairRange:
       case eArgRepeatPairRangeOptional:
-        // These should not be hit, as they should pass the IsPairType test
-        // above, and control should
-        // have gone into the other branch of the if statement.
+        // These should not be hit, as they should pass the IsPairType
+        // test above, and control should have gone into the other branch
+        // of the if statement.
         break;
       }
     }
@@ -856,10 +856,9 @@
   }
   if (!IsDashDashCommand() && options && options->NumCommandOptions() > 0) {
     if (WantsRawCommandString() && !WantsCompletion()) {
-      // Emit the message about using ' -- ' between the end of the command
-      // options and the raw input
-      // conditionally, i.e., only if the command object does not want
-      // completion.
+      // Emit the message about using ' -- ' between the end of the
+      // command options and the raw input conditionally, i.e., only if
+      // the command object does not want completion.
       interpreter.OutputFormattedHelpText(
           output_strm, "", "",
           "\nImportant Note: Because this command takes 'raw' input, if you "
@@ -868,8 +867,8 @@
           "beginning of the raw input.",
           1);
     } else if (GetNumArgumentEntries() > 0) {
-      // Also emit a warning about using "--" in case you are using a command
-      // that takes options and arguments.
+      // Also emit a warning about using "--" in case you are using a
+      // command that takes options and arguments.
       interpreter.OutputFormattedHelpText(
           output_strm, "", "",
           "\nThis command takes options and free-form arguments.  If your "
@@ -898,9 +897,9 @@
   id_range_arg.arg_type = IDRange;
   id_range_arg.arg_repetition = eArgRepeatOptional;
 
-  // The first (and only) argument for this command could be either an id or an
-  // id_range.
-  // Push both variants into the entry for the first argument for this command.
+  // The first (and only) argument for this command could be either an id
+  // or an id_range. Push both variants into the entry for the first
+  // argument for this command.
   arg.push_back(id_arg);
   arg.push_back(id_range_arg);
 }
Index: source/Interpreter/CommandObjectRegexCommand.cpp
===================================================================
--- source/Interpreter/CommandObjectRegexCommand.cpp
+++ source/Interpreter/CommandObjectRegexCommand.cpp
@@ -62,9 +62,9 @@
         // Interpret the new command and return this as the result!
         if (m_interpreter.GetExpandRegexAliases())
           result.GetOutputStream().Printf("%s\n", new_command.c_str());
-        // Pass in true for "no context switching".  The command that called us
-        // should have set up the context
-        // appropriately, we shouldn't have to redo that.
+        // Pass in true for "no context switching".  The command that
+        // called us should have set up the context appropriately, we
+        // shouldn't have to redo that.
         return m_interpreter.HandleCommand(new_command.c_str(),
                                            eLazyBoolCalculate, result, nullptr,
                                            true, true);
Index: source/Interpreter/CommandObjectScript.cpp
===================================================================
--- source/Interpreter/CommandObjectScript.cpp
+++ source/Interpreter/CommandObjectScript.cpp
@@ -43,8 +43,8 @@
 bool CommandObjectScript::DoExecute(const char *command,
                                     CommandReturnObject &result) {
 #ifdef LLDB_DISABLE_PYTHON
-  // if we ever support languages other than Python this simple #ifdef won't
-  // work
+  // if we ever support languages other than Python this simple #ifdef
+  // won't work
   result.AppendError("your copy of LLDB does not support scripting.");
   result.SetStatus(eReturnStatusFailed);
   return false;
@@ -66,8 +66,8 @@
   }
 
   DataVisualization::ForceUpdate(); // script might change Python code we use
-                                    // for formatting.. make sure we keep up to
-                                    // date with it
+                                    // for formatting.. make sure we keep
+                                    // up to date with it
 
   if (command == nullptr || command[0] == '\0') {
     script_interpreter->ExecuteInterpreterLoop();
@@ -75,7 +75,8 @@
     return result.Succeeded();
   }
 
-  // We can do better when reporting the status of one-liner script execution.
+  // We can do better when reporting the status of one-liner script
+  // execution.
   if (script_interpreter->ExecuteOneLine(command, &result))
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
   else
Index: source/Interpreter/CommandReturnObject.cpp
===================================================================
--- source/Interpreter/CommandReturnObject.cpp
+++ source/Interpreter/CommandReturnObject.cpp
@@ -25,8 +25,8 @@
   if (s.empty()) {
     add_newline = add_newline_if_empty;
   } else {
-    // We already checked for empty above, now make sure there is a newline
-    // in the error, and if there isn't one, add one.
+    // We already checked for empty above, now make sure there is a
+    // newline in the error, and if there isn't one, add one.
     strm.Write(s.c_str(), s.size());
 
     const char last_char = *s.rbegin();
@@ -96,8 +96,8 @@
   GetErrorStream() << "warning: " << in_string << "\n";
 }
 
-// Similar to AppendWarning, but do not prepend 'warning: ' to message, and
-// don't append "\n" to the end of it.
+// Similar to AppendWarning, but do not prepend 'warning: ' to message,
+// and don't append "\n" to the end of it.
 
 void CommandReturnObject::AppendRawWarning(llvm::StringRef in_string) {
   if (in_string.empty())
Index: source/Interpreter/OptionArgParser.cpp
===================================================================
--- source/Interpreter/OptionArgParser.cpp
+++ source/Interpreter/OptionArgParser.cpp
@@ -206,8 +206,8 @@
 
   } else {
     // Since the compiler can't handle things like "main + 12" we should
-    // try to do this for now. The compiler doesn't like adding offsets
-    // to function pointer types.
+    // try to do this for now. The compiler doesn't like adding offsets to
+    // function pointer types.
     static RegularExpression g_symbol_plus_offset_regex(
         "^(.*)([-\\+])[[:space:]]*(0x[0-9A-Fa-f]+|[0-9]+)[[:space:]]*$");
     RegularExpression::Match regex_match(3);
Index: source/Interpreter/OptionGroupBoolean.cpp
===================================================================
--- source/Interpreter/OptionGroupBoolean.cpp
+++ source/Interpreter/OptionGroupBoolean.cpp
@@ -45,8 +45,8 @@
                                           ExecutionContext *execution_context) {
   Status error;
   if (m_option_definition.option_has_arg == OptionParser::eNoArgument) {
-    // Not argument, toggle the default value and mark the option as having been
-    // set
+    // Not argument, toggle the default value and mark the option as
+    // having been set
     m_value.SetCurrentValue(!m_value.GetDefaultValue());
     m_value.SetOptionWasSet();
   } else {
Index: source/Interpreter/OptionGroupFormat.cpp
===================================================================
--- source/Interpreter/OptionGroupFormat.cpp
+++ source/Interpreter/OptionGroupFormat.cpp
@@ -100,10 +100,10 @@
       gdb_format_str = gdb_format_str.drop_front();
     }
 
-    // We the first character of the "gdb_format_str" is not the
-    // NULL terminator, we didn't consume the entire string and
-    // something is wrong. Also, if none of the format, size or count
-    // was specified correctly, then abort.
+    // We the first character of the "gdb_format_str" is not the NULL
+    // terminator, we didn't consume the entire string and something is
+    // wrong. Also, if none of the format, size or count was specified
+    // correctly, then abort.
     if (!gdb_format_str.empty() ||
         (format == eFormatInvalid && byte_size == 0 && count == 0)) {
       // Nothing got set correctly
@@ -113,8 +113,8 @@
     }
 
     // At least one of the format, size or count was set correctly.
-    // Anything that wasn't set correctly should be set to the
-    // previous default
+    // Anything that wasn't set correctly should be set to the previous
+    // default
     if (format == eFormatInvalid)
       ParserGDBFormatLetter(execution_context, m_prev_gdb_format, format,
                             byte_size);
@@ -127,9 +127,9 @@
         ParserGDBFormatLetter(execution_context, m_prev_gdb_size, format,
                               byte_size);
     } else {
-      // Byte size is disabled, make sure it wasn't specified
-      // but if this is an address, it's actually necessary to
-      // specify one so don't error out
+      // Byte size is disabled, make sure it wasn't specified but if this
+      // is an address, it's actually necessary to specify one so don't
+      // error out
       if (byte_size > 0 && format != lldb::eFormatAddressInfo) {
         error.SetErrorString(
             "this command doesn't support specifying a byte size");
@@ -138,8 +138,8 @@
     }
 
     if (count_enabled) {
-      // Count is enabled and was not set, set it to the default for gdb format
-      // statements (which is 1).
+      // Count is enabled and was not set, set it to the default for gdb
+      // format statements (which is 1).
       if (count == 0)
         count = 1;
     } else {
@@ -235,11 +235,10 @@
   case 'w':
   case 'g':
     {
-      // Size isn't used for printing instructions, so if a size is specified, and
-      // the previous format was
-      // 'i', then we should reset it to the default ('x').  Otherwise we'll
-      // continue to print as instructions,
-      // which isn't expected.
+      // Size isn't used for printing instructions, so if a size is
+      // specified, and the previous format was 'i', then we should reset
+      // it to the default ('x').  Otherwise we'll continue to print as
+      // instructions, which isn't expected.
       if (format_letter == 'b')
           byte_size = 1;
       else if (format_letter == 'h')
Index: source/Interpreter/OptionGroupValueObjectDisplay.cpp
===================================================================
--- source/Interpreter/OptionGroupValueObjectDisplay.cpp
+++ source/Interpreter/OptionGroupValueObjectDisplay.cpp
@@ -187,7 +187,8 @@
   if (target_sp)
     use_dynamic = target_sp->GetPreferDynamicValue();
   else {
-    // If we don't have any targets, then dynamic values won't do us much good.
+    // If we don't have any targets, then dynamic values won't do us much
+    // good.
     use_dynamic = lldb::eNoDynamicValues;
   }
 }
Index: source/Interpreter/OptionGroupVariable.cpp
===================================================================
--- source/Interpreter/OptionGroupVariable.cpp
+++ source/Interpreter/OptionGroupVariable.cpp
@@ -132,12 +132,12 @@
 
 llvm::ArrayRef<OptionDefinition> OptionGroupVariable::GetDefinitions() {
   auto result = llvm::makeArrayRef(g_variable_options);
-  // Show the "--no-args", "--no-locals" and "--show-globals"
-  // options if we are showing frame specific options
+  // Show the "--no-args", "--no-locals" and "--show-globals" options if
+  // we are showing frame specific options
   if (include_frame_options)
     return result;
 
-  // Skip the "--no-args", "--no-locals" and "--show-globals"
-  // options if we are not showing frame specific options (globals only)
+  // Skip the "--no-args", "--no-locals" and "--show-globals" options if
+  // we are not showing frame specific options (globals only)
   return result.drop_front(NUM_FRAME_OPTS);
 }
Index: source/Interpreter/OptionValue.cpp
===================================================================
--- source/Interpreter/OptionValue.cpp
+++ source/Interpreter/OptionValue.cpp
@@ -21,8 +21,7 @@
 
 //-------------------------------------------------------------------------
 // Get this value as a uint64_t value if it is encoded as a boolean,
-// uint64_t or int64_t. Other types will cause "fail_value" to be
-// returned
+// uint64_t or int64_t. Other types will cause "fail_value" to be returned
 //-------------------------------------------------------------------------
 uint64_t OptionValue::GetUInt64Value(uint64_t fail_value, bool *success_ptr) {
   if (success_ptr)
@@ -508,8 +507,8 @@
 
 lldb::OptionValueSP OptionValue::CreateValueFromCStringForTypeMask(
     const char *value_cstr, uint32_t type_mask, Status &error) {
-  // If only 1 bit is set in the type mask for a dictionary or array
-  // then we know how to decode a value from a cstring
+  // If only 1 bit is set in the type mask for a dictionary or array then
+  // we know how to decode a value from a cstring
   lldb::OptionValueSP value_sp;
   switch (type_mask) {
   case 1u << eTypeArch:
Index: source/Interpreter/OptionValueDictionary.cpp
===================================================================
--- source/Interpreter/OptionValueDictionary.cpp
+++ source/Interpreter/OptionValueDictionary.cpp
@@ -128,9 +128,7 @@
 
       if (key.front() == '[') {
         // Key name starts with '[', so the key value must be in single or
-        // double quotes like:
-        // ['<key>']
-        // ["<key>"]
+        // double quotes like: ['<key>'] ["<key>"]
         if ((key.size() > 2) && (key.back() == ']')) {
           // Strip leading '[' and trailing ']'
           key = key.substr(1, key.size() - 2);
@@ -286,8 +284,8 @@
 bool OptionValueDictionary::SetValueForKey(const ConstString &key,
                                            const lldb::OptionValueSP &value_sp,
                                            bool can_replace) {
-  // Make sure the value_sp object is allowed to contain
-  // values of the type passed in...
+  // Make sure the value_sp object is allowed to contain values of the
+  // type passed in...
   if (value_sp && (m_type_mask & value_sp->GetTypeAsMask())) {
     if (!can_replace) {
       collection::const_iterator pos = m_values.find(key);
Index: source/Interpreter/OptionValueFileSpec.cpp
===================================================================
--- source/Interpreter/OptionValueFileSpec.cpp
+++ source/Interpreter/OptionValueFileSpec.cpp
@@ -66,16 +66,13 @@
   case eVarSetOperationReplace:
   case eVarSetOperationAssign:
     if (value.size() > 0) {
-      // The setting value may have whitespace, double-quotes, or single-quotes
-      // around the file
-      // path to indicate that internal spaces are not word breaks.  Strip off
-      // any ws & quotes
-      // from the start and end of the file path - we aren't doing any word //
-      // breaking here so
-      // the quoting is unnecessary.  NB this will cause a problem if someone
-      // tries to specify
-      // a file path that legitimately begins or ends with a " or ' character,
-      // or whitespace.
+      // The setting value may have whitespace, double-quotes, or single-
+      // quotes around the file path to indicate that internal spaces are
+      // not word breaks.  Strip off any ws & quotes from the start and
+      // end of the file path - we aren't doing any word // breaking here
+      // so the quoting is unnecessary.  NB this will cause a problem if
+      // someone tries to specify a file path that legitimately begins or
+      // ends with a " or ' character, or whitespace.
       value = value.trim("\"' \t");
       m_value_was_set = true;
       m_current_value.SetFile(value.str(), m_resolve);
Index: source/Interpreter/OptionValueFormatEntity.cpp
===================================================================
--- source/Interpreter/OptionValueFormatEntity.cpp
+++ source/Interpreter/OptionValueFormatEntity.cpp
@@ -63,13 +63,11 @@
 
   case eVarSetOperationReplace:
   case eVarSetOperationAssign: {
-    // Check if the string starts with a quote character after removing leading
-    // and trailing spaces.
-    // If it does start with a quote character, make sure it ends with the same
-    // quote character
-    // and remove the quotes before we parse the format string. If the string
-    // doesn't start with
-    // a quote, leave the string alone and parse as is.
+    // Check if the string starts with a quote character after removing
+    // leading and trailing spaces. If it does start with a quote
+    // character, make sure it ends with the same quote character and
+    // remove the quotes before we parse the format string. If the string
+    // doesn't start with a quote, leave the string alone and parse as is.
     llvm::StringRef trimmed_value_str = value_str.trim();
     if (!trimmed_value_str.empty()) {
       const char first_char = trimmed_value_str[0];
Index: source/Interpreter/OptionValuePathMappings.cpp
===================================================================
--- source/Interpreter/OptionValuePathMappings.cpp
+++ source/Interpreter/OptionValuePathMappings.cpp
@@ -53,8 +53,8 @@
     break;
 
   case eVarSetOperationReplace:
-    // Must be at least one index + 1 pair of paths, and the pair count must be
-    // even
+    // Must be at least one index + 1 pair of paths, and the pair count
+    // must be even
     if (argc >= 3 && (((argc - 1) & 1) == 0)) {
       uint32_t idx =
           StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
@@ -125,8 +125,8 @@
 
   case eVarSetOperationInsertBefore:
   case eVarSetOperationInsertAfter:
-    // Must be at least one index + 1 pair of paths, and the pair count must be
-    // even
+    // Must be at least one index + 1 pair of paths, and the pair count
+    // must be even
     if (argc >= 3 && (((argc - 1) & 1) == 0)) {
       uint32_t idx =
           StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
Index: source/Interpreter/OptionValueProperties.cpp
===================================================================
--- source/Interpreter/OptionValueProperties.cpp
+++ source/Interpreter/OptionValueProperties.cpp
@@ -35,15 +35,13 @@
       m_name(global_properties.m_name),
       m_properties(global_properties.m_properties),
       m_name_to_index(global_properties.m_name_to_index) {
-  // We now have an exact copy of "global_properties". We need to now
-  // find all non-global settings and copy the property values so that
-  // all non-global settings get new OptionValue instances created for
-  // them.
+  // We now have an exact copy of "global_properties". We need to now find
+  // all non-global settings and copy the property values so that all non-
+  // global settings get new OptionValue instances created for them.
   const size_t num_properties = m_properties.size();
   for (size_t i = 0; i < num_properties; ++i) {
-    // Duplicate any values that are not global when constructing properties
-    // from
-    // a global copy
+    // Duplicate any values that are not global when constructing
+    // properties from a global copy
     if (m_properties[i].IsGlobal() == false) {
       lldb::OptionValueSP new_value_sp(m_properties[i].GetValue()->DeepCopy());
       m_properties[i].SetOptionValue(new_value_sp);
@@ -157,15 +155,14 @@
   case '{':
     // Predicate matching for predicates like
     // "<setting-name>{<predicate>}"
-    // strings are parsed by the current OptionValueProperties subclass
-    // to mean whatever they want to. For instance a subclass of
+    // strings are parsed by the current OptionValueProperties subclass to
+    // mean whatever they want to. For instance a subclass of
     // OptionValueProperties for a lldb_private::Target might implement:
     // "target.run-args{arch==i386}"   -- only set run args if the arch is
-    // i386
-    // "target.run-args{path=/tmp/a/b/c/a.out}" -- only set run args if the
-    // path matches
-    // "target.run-args{basename==test&&arch==x86_64}" -- only set run args
-    // if executable basename is "test" and arch is "x86_64"
+    // i386 "target.run-args{path=/tmp/a/b/c/a.out}" -- only set run args
+    // if the path matches "target.run-args{basename==test&&arch==x86_64}"
+    // -- only set run args if executable basename is "test" and arch is
+    // "x86_64"
     if (sub_name[1]) {
       llvm::StringRef predicate_start = sub_name.drop_front();
       size_t pos = predicate_start.find_first_of('}');
@@ -189,9 +186,9 @@
     break;
 
   case '[':
-    // Array or dictionary access for subvalues like:
-    // "[12]"       -- access 12th array element
-    // "['hello']"  -- dictionary access of key named hello
+    // Array or dictionary access for subvalues like: "[12]"       --
+    // access 12th array element "['hello']"  -- dictionary access of key
+    // named hello
     return value_sp->GetSubValue(exe_ctx, sub_name, will_modify, error);
 
   default:
Index: source/Interpreter/OptionValueSInt64.cpp
===================================================================
--- source/Interpreter/OptionValueSInt64.cpp
+++ source/Interpreter/OptionValueSInt64.cpp
@@ -21,8 +21,8 @@
 
 void OptionValueSInt64::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                                   uint32_t dump_mask) {
-  // printf ("%p: DumpValue (exe_ctx=%p, strm, mask) m_current_value = %" PRIi64
-  // "\n", this, exe_ctx, m_current_value);
+  // printf ("%p: DumpValue (exe_ctx=%p, strm, mask) m_current_value = %"
+  // PRIi64 "\n", this, exe_ctx, m_current_value);
   if (dump_mask & eDumpOptionType)
     strm.Printf("(%s)", GetTypeAsCString());
   //    if (dump_mask & eDumpOptionName)
Index: source/Interpreter/Options.cpp
===================================================================
--- source/Interpreter/Options.cpp
+++ source/Interpreter/Options.cpp
@@ -56,8 +56,8 @@
   OptionSet::const_iterator pos_a;
   OptionSet::const_iterator pos_b;
 
-  // set_a is a subset of set_b if every member of set_a is also a member of
-  // set_b
+  // set_a is a subset of set_b if every member of set_a is also a member
+  // of set_b
 
   for (pos_a = set_a.begin(); pos_a != set_a.end() && is_a_subset; ++pos_a) {
     pos_b = set_b.find(*pos_a);
@@ -68,8 +68,8 @@
   return is_a_subset;
 }
 
-// Returns the set difference set_a - set_b, i.e. { x | ElementOf (x, set_a) &&
-// !ElementOf (x, set_b) }
+// Returns the set difference set_a - set_b, i.e. { x | ElementOf (x,
+// set_a) && !ElementOf (x, set_b) }
 
 size_t Options::OptionsSetDiff(const OptionSet &set_a, const OptionSet &set_b,
                                OptionSet &diffs) {
@@ -88,8 +88,8 @@
   return num_diffs;
 }
 
-// Returns the union of set_a and set_b.  Does not put duplicate members into
-// the union.
+// Returns the union of set_a and set_b.  Does not put duplicate members
+// into the union.
 
 void Options::OptionsSetUnion(const OptionSet &set_a, const OptionSet &set_b,
                               OptionSet &union_set) {
@@ -101,7 +101,8 @@
   for (pos = set_a.begin(); pos != set_a.end(); ++pos)
     union_set.insert(*pos);
 
-  // Put all the elements of set_b that are not already there into the union.
+  // Put all the elements of set_b that are not already there into the
+  // union.
   for (pos = set_b.begin(); pos != set_b.end(); ++pos) {
     pos_union = union_set.find(*pos);
     if (pos_union == union_set.end())
@@ -115,19 +116,18 @@
   int num_levels = GetRequiredOptions().size();
   if (num_levels) {
     for (int i = 0; i < num_levels && !options_are_valid; ++i) {
-      // This is the correct set of options if:  1). m_seen_options contains all
-      // of m_required_options[i]
-      // (i.e. all the required options at this level are a subset of
-      // m_seen_options); AND
-      // 2). { m_seen_options - m_required_options[i] is a subset of
-      // m_options_options[i] (i.e. all the rest of
-      // m_seen_options are in the set of optional options at this level.
+      // This is the correct set of options if:  1). m_seen_options
+      // contains all of m_required_options[i] (i.e. all the required
+      // options at this level are a subset of m_seen_options); AND 2). {
+      // m_seen_options - m_required_options[i] is a subset of
+      // m_options_options[i] (i.e. all the rest of m_seen_options are in
+      // the set of optional options at this level.
 
       // Check to see if all of m_required_options[i] are a subset of
       // m_seen_options
       if (IsASubset(GetRequiredOptions()[i], m_seen_options)) {
-        // Construct the set difference: remaining_options = {m_seen_options} -
-        // {m_required_options[i]}
+        // Construct the set difference: remaining_options =
+        // {m_seen_options} - {m_required_options[i]}
         OptionSet remaining_options;
         OptionsSetDiff(m_seen_options, GetRequiredOptions()[i],
                        remaining_options);
@@ -151,9 +151,8 @@
   return options_are_valid;
 }
 
-// This is called in the Options constructor, though we could call it lazily if
-// that ends up being
-// a performance problem.
+// This is called in the Options constructor, though we could call it
+// lazily if that ends up being a performance problem.
 
 void Options::BuildValidOptionSets() {
   // Check to see if we already did this.
@@ -264,15 +263,14 @@
   return &m_getopt_table.front();
 }
 
-// This function takes INDENT, which tells how many spaces to output at the
-// front of each line; SPACES, which is
-// a string containing 80 spaces; and TEXT, which is the text that is to be
-// output.   It outputs the text, on
-// multiple lines if necessary, to RESULT, with INDENT spaces at the front of
-// each line.  It breaks lines on spaces,
-// tabs or newlines, shortening the line if necessary to not break in the middle
-// of a word.  It assumes that each
-// output line should contain a maximum of OUTPUT_MAX_COLUMNS characters.
+// This function takes INDENT, which tells how many spaces to output at
+// the front of each line; SPACES, which is a string containing 80 spaces;
+// and TEXT, which is the text that is to be output.   It outputs the
+// text, on multiple lines if necessary, to RESULT, with INDENT spaces at
+// the front of each line.  It breaks lines on spaces, tabs or newlines,
+// shortening the line if necessary to not break in the middle of a word.
+// It assumes that each output line should contain a maximum of
+// OUTPUT_MAX_COLUMNS characters.
 
 void Options::OutputFormattedUsageText(Stream &strm,
                                        const OptionDefinition &option_def,
@@ -305,8 +303,8 @@
     int sub_len;
 
     while (end < final_end) {
-      // Don't start the 'text' on a space, since we're already outputting the
-      // indentation.
+      // Don't start the 'text' on a space, since we're already outputting
+      // the indentation.
       while ((start < final_end) && (actual_text[start] == ' '))
         start++;
 
@@ -314,8 +312,8 @@
       if (end > final_end)
         end = final_end;
       else {
-        // If we're not at the end of the text, make sure we break the line on
-        // white space.
+        // If we're not at the end of the text, make sure we break the
+        // line on white space.
         while (end > start && actual_text[end] != ' ' &&
                actual_text[end] != '\t' && actual_text[end] != '\n')
           end--;
@@ -421,8 +419,8 @@
 
   strm.IndentMore(2);
 
-  // First, show each usage level set of options, e.g. <cmd>
-  // [options-for-level-0]
+  // First, show each usage level set of options, e.g. <cmd> [options-for-
+  // level-0]
   //                                                   <cmd>
   //                                                   [options-for-level-1]
   //                                                   etc.
@@ -450,8 +448,8 @@
         cmd->GetFormattedCommandArguments(args_str, opt_set_mask);
 
       // First go through and print all options that take no arguments as
-      // a single string. If a command has "-a" "-b" and "-c", this will show
-      // up as [-abc]
+      // a single string. If a command has "-a" "-b" and "-c", this will
+      // show up as [-abc]
 
       std::set<int> options;
       std::set<int>::const_iterator options_pos, options_end;
@@ -506,7 +504,8 @@
         strm.PutChar(']');
       }
 
-      // First go through and print the required options (list them up front).
+      // First go through and print the required options (list them up
+      // front).
 
       for (auto &def : opt_defs) {
         if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) {
@@ -515,7 +514,8 @@
         }
       }
 
-      // Now go through again, and this time only print the optional options.
+      // Now go through again, and this time only print the optional
+      // options.
 
       for (auto &def : opt_defs) {
         if (def.usage_mask & opt_set_mask) {
@@ -548,30 +548,30 @@
   strm.Printf("\n\n");
 
   if (!only_print_args) {
-    // Now print out all the detailed information about the various options:
-    // long form, short form and help text:
+    // Now print out all the detailed information about the various
+    // options: long form, short form and help text:
     //   -short <argument> ( --long_name <argument> )
     //   help text
 
-    // This variable is used to keep track of which options' info we've printed
-    // out, because some options can be in
-    // more than one usage level, but we only want to print the long form of its
-    // information once.
+    // This variable is used to keep track of which options' info we've
+    // printed out, because some options can be in more than one usage
+    // level, but we only want to print the long form of its information
+    // once.
 
     std::multimap<int, uint32_t> options_seen;
     strm.IndentMore(5);
 
-    // Put the unique command options in a vector & sort it, so we can output
-    // them alphabetically (by short_option)
-    // when writing out detailed help for each option.
+    // Put the unique command options in a vector & sort it, so we can
+    // output them alphabetically (by short_option) when writing out
+    // detailed help for each option.
 
     i = 0;
     for (auto &def : opt_defs)
       options_seen.insert(std::make_pair(def.short_option, i++));
 
-    // Go through the unique'd and alphabetically sorted vector of options, find
-    // the table entry for each option
-    // and write out the detailed help information for that option.
+    // Go through the unique'd and alphabetically sorted vector of
+    // options, find the table entry for each option and write out the
+    // detailed help information for that option.
 
     bool first_option_printed = false;
 
@@ -626,15 +626,12 @@
   strm.SetIndentLevel(save_indent_level);
 }
 
-// This function is called when we have been given a potentially incomplete set
-// of
-// options, such as when an alias has been defined (more options might be added
-// at
-// at the time the alias is invoked).  We need to verify that the options in the
-// set
-// m_seen_options are all part of a set that may be used together, but
-// m_seen_options
-// may be missing some of the "required" options.
+// This function is called when we have been given a potentially
+// incomplete set of options, such as when an alias has been defined (more
+// options might be added at at the time the alias is invoked).  We need
+// to verify that the options in the set m_seen_options are all part of a
+// set that may be used together, but m_seen_options may be missing some
+// of the "required" options.
 
 bool Options::VerifyPartialOptions(CommandReturnObject &result) {
   bool options_are_valid = false;
@@ -643,10 +640,9 @@
   if (num_levels) {
     for (int i = 0; i < num_levels && !options_are_valid; ++i) {
       // In this case we are treating all options as optional rather than
-      // required.
-      // Therefore a set of options is correct if m_seen_options is a subset of
-      // the
-      // union of m_required_options and m_optional_options.
+      // required. Therefore a set of options is correct if m_seen_options
+      // is a subset of the union of m_required_options and
+      // m_optional_options.
       OptionSet union_set;
       OptionsSetUnion(GetRequiredOptions()[i], GetOptionalOptions()[i],
                       union_set);
@@ -665,9 +661,10 @@
     lldb_private::StringList &matches) {
   word_complete = true;
 
-  // For now we just scan the completions to see if the cursor position is in
-  // an option or its argument.  Otherwise we'll call HandleArgumentCompletion.
-  // In the future we can use completion to validate options as well if we want.
+  // For now we just scan the completions to see if the cursor position is
+  // in an option or its argument.  Otherwise we'll call
+  // HandleArgumentCompletion. In the future we can use completion to
+  // validate options as well if we want.
 
   auto opt_defs = GetDefinitions();
 
@@ -684,9 +681,8 @@
 
       if (opt_defs_index == OptionArgElement::eBareDash) {
         // We're completing a bare dash.  That means all options are open.
-        // FIXME: We should scan the other options provided and only complete
-        // options
-        // within the option group they belong to.
+        // FIXME: We should scan the other options provided and only
+        // complete options within the option group they belong to.
         char opt_str[3] = {'-', 'a', '\0'};
 
         for (auto &def : opt_defs) {
@@ -709,12 +705,11 @@
         }
         return true;
       } else if (opt_defs_index != OptionArgElement::eUnrecognizedArg) {
-        // We recognized it, if it an incomplete long option, complete it anyway
-        // (getopt_long_only is
-        // happy with shortest unique string, but it's still a nice thing to
-        // do.)  Otherwise return
-        // The string so the upper level code will know this is a full match and
-        // add the " ".
+        // We recognized it, if it an incomplete long option, complete it
+        // anyway (getopt_long_only is happy with shortest unique string,
+        // but it's still a nice thing to do.)  Otherwise return The
+        // string so the upper level code will know this is a full match
+        // and add the " ".
         if (cur_opt_str && strlen(cur_opt_str) > 2 && cur_opt_str[0] == '-' &&
             cur_opt_str[1] == '-' &&
             strcmp(opt_defs[opt_defs_index].long_option, cur_opt_str) != 0) {
@@ -728,12 +723,11 @@
         }
       } else {
         // FIXME - not handling wrong options yet:
-        // Check to see if they are writing a long option & complete it.
-        // I think we will only get in here if the long option table has two
-        // elements
-        // that are not unique up to this point.  getopt_long_only does shortest
-        // unique match
-        // for long options already.
+        // Check to see if they are writing a long option & complete it. I
+        // think we will only get in here if the long option table has two
+        // elements that are not unique up to this point.
+        // getopt_long_only does shortest unique match for long options
+        // already.
 
         if (cur_opt_str && strlen(cur_opt_str) > 2 && cur_opt_str[0] == '-' &&
             cur_opt_str[1] == '-') {
@@ -744,8 +738,9 @@
             if (strstr(def.long_option, cur_opt_str + 2) == def.long_option) {
               std::string full_name("--");
               full_name.append(def.long_option);
-              // The options definitions table has duplicates because of the
-              // way the grouping information is stored, so only add once.
+              // The options definitions table has duplicates because of
+              // the way the grouping information is stored, so only add
+              // once.
               bool duplicate = false;
               for (size_t k = 0; k < matches.GetSize(); k++) {
                 if (matches.GetStringAtIndex(k) == full_name) {
@@ -762,8 +757,8 @@
       }
 
     } else if (opt_arg_pos == cursor_index) {
-      // Okay the cursor is on the completion of an argument.
-      // See if it has a completion, otherwise return no matches.
+      // Okay the cursor is on the completion of an argument. See if it
+      // has a completion, otherwise return no matches.
 
       if (opt_defs_index != -1) {
         HandleOptionArgumentCompletion(
@@ -796,7 +791,8 @@
   int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
   int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
 
-  // See if this is an enumeration type option, and if so complete it here:
+  // See if this is an enumeration type option, and if so complete it
+  // here:
 
   OptionEnumValueElement *enum_values = opt_defs[opt_defs_index].enum_values;
   if (enum_values != nullptr) {
@@ -815,10 +811,8 @@
 
   // If this is a source file or symbol type completion, and  there is a
   // -shlib option somewhere in the supplied arguments, then make a search
-  // filter
-  // for that shared library.
-  // FIXME: Do we want to also have an "OptionType" so we don't have to match
-  // string names?
+  // filter for that shared library. FIXME: Do we want to also have an
+  // "OptionType" so we don't have to match string names?
 
   uint32_t completion_mask = opt_defs[opt_defs_index].completion_type;
 
@@ -908,8 +902,8 @@
 Status OptionGroupOptions::SetOptionValue(uint32_t option_idx,
                                           llvm::StringRef option_value,
                                           ExecutionContext *execution_context) {
-  // After calling OptionGroupOptions::Append(...), you must finalize the groups
-  // by calling OptionGroupOptions::Finlize()
+  // After calling OptionGroupOptions::Append(...), you must finalize the
+  // groups by calling OptionGroupOptions::Finlize()
   assert(m_did_finalize);
   Status error;
   if (option_idx < m_option_infos.size()) {
@@ -952,20 +946,22 @@
   return error;
 }
 
-// OptionParser permutes the arguments while processing them, so we create a
-// temporary array holding to avoid modification of the input arguments. The
-// options themselves are never modified, but the API expects a char * anyway,
-// hence the const_cast.
+// OptionParser permutes the arguments while processing them, so we create
+// a temporary array holding to avoid modification of the input arguments.
+// The options themselves are never modified, but the API expects a char *
+// anyway, hence the const_cast.
 static std::vector<char *> GetArgvForParsing(const Args &args) {
   std::vector<char *> result;
-  // OptionParser always skips the first argument as it is based on getopt().
+  // OptionParser always skips the first argument as it is based on
+  // getopt().
   result.push_back(const_cast<char *>("<FAKE-ARG0>"));
   for (const Args::ArgEntry &entry : args)
     result.push_back(const_cast<char *>(entry.c_str()));
   return result;
 }
 
-// Given a permuted argument, find it's position in the original Args vector.
+// Given a permuted argument, find it's position in the original Args
+// vector.
 static Args::const_iterator FindOriginalIter(const char *arg,
                                              const Args &original) {
   return llvm::find_if(
@@ -977,8 +973,8 @@
   return std::distance(original.begin(), FindOriginalIter(arg, original));
 }
 
-// Construct a new Args object, consisting of the entries from the original
-// arguments, but in the permuted order.
+// Construct a new Args object, consisting of the entries from the
+// original arguments, but in the permuted order.
 static Args ReconstituteArgsAfterParsing(llvm::ArrayRef<char *> parsed,
                                          const Args &original) {
   Args result;
@@ -1111,10 +1107,10 @@
     option_arg_vector->emplace_back(option_str.GetString(), has_arg,
                                     option_arg);
 
-    // Find option in the argument list; also see if it was supposed to take
-    // an argument and if one was supplied.  Remove option (and argument, if
-    // given) from the argument list.  Also remove them from the
-    // raw_input_string, if one was passed in.
+    // Find option in the argument list; also see if it was supposed to
+    // take an argument and if one was supplied.  Remove option (and
+    // argument, if given) from the argument list.  Also remove them from
+    // the raw_input_string, if one was passed in.
     size_t idx =
         FindArgumentIndexForOption(args_copy, long_options[long_options_index]);
     if (idx == size_t(-1))
@@ -1155,8 +1151,8 @@
   if (long_options == nullptr)
     return option_element_vector;
 
-  // Leading : tells getopt to return a : for a missing option argument AND
-  // to suppress error messages.
+  // Leading : tells getopt to return a : for a missing option argument
+  // AND to suppress error messages.
 
   sstr << ":";
   for (int i = 0; long_options[i].definition != nullptr; ++i) {
@@ -1185,8 +1181,9 @@
 
   std::vector<char *> dummy_vec = GetArgvForParsing(args);
 
-  // I stick an element on the end of the input, because if the last element
-  // is option that requires an argument, getopt_long_only will freak out.
+  // I stick an element on the end of the input, because if the last
+  // element is option that requires an argument, getopt_long_only will
+  // freak out.
   dummy_vec.push_back(const_cast<char *>("<FAKE-VALUE>"));
 
   bool failed_once = false;
@@ -1207,16 +1204,16 @@
       failed_once = true;
 
       // If this is a bare  "--" we mark it as such so we can complete it
-      // successfully later.  Handling the "--" is a little tricky, since that
-      // may mean end of options or arguments, or the user might want to
-      // complete options by long name.  I make this work by checking whether
-      // the cursor is in the "--" argument, and if so I assume we're
-      // completing the long option, otherwise I let it pass to
-      // OptionParser::Parse which will terminate the option parsing.  Note, in
-      // either case we continue parsing the line so we can figure out what
-      // other options were passed.  This will be useful when we come to
-      // restricting completions based on what other options we've seen on the
-      // line.
+      // successfully later.  Handling the "--" is a little tricky, since
+      // that may mean end of options or arguments, or the user might want
+      // to complete options by long name.  I make this work by checking
+      // whether the cursor is in the "--" argument, and if so I assume
+      // we're completing the long option, otherwise I let it pass to
+      // OptionParser::Parse which will terminate the option parsing.
+      // Note, in either case we continue parsing the line so we can
+      // figure out what other options were passed.  This will be useful
+      // when we come to restricting completions based on what other
+      // options we've seen on the line.
 
       if (static_cast<size_t>(OptionParser::GetOptionIndex()) <
               dummy_vec.size() &&
@@ -1339,11 +1336,10 @@
   }
 
   // Finally we have to handle the case where the cursor index points at a
-  // single "-".  We want to mark that in
-  // the option_element_vector, but only if it is not after the "--".  But it
-  // turns out that OptionParser::Parse just ignores
-  // an isolated "-".  So we have to look it up by hand here.  We only care if
-  // it is AT the cursor position.
+  // single "-".  We want to mark that in the option_element_vector, but
+  // only if it is not after the "--".  But it turns out that
+  // OptionParser::Parse just ignores an isolated "-".  So we have to look
+  // it up by hand here.  We only care if it is AT the cursor position.
   // Note, a single quoted dash is not the same as a single dash...
 
   const Args::ArgEntry &cursor = args[cursor_index];
@@ -1426,8 +1422,8 @@
       const OptionDefinition *def = long_options[long_options_index].definition;
 
       if (!platform_sp) {
-        // User did not pass in an explicit platform.  Try to grab
-        // from the execution context.
+        // User did not pass in an explicit platform.  Try to grab from
+        // the execution context.
         TargetSP target_sp =
             execution_context ? execution_context->GetTargetSP() : TargetSP();
         platform_sp = target_sp ? target_sp->GetPlatform() : PlatformSP();
@@ -1435,9 +1431,8 @@
       OptionValidator *validator = def->validator;
 
       if (!platform_sp && require_validation) {
-        // Caller requires validation but we cannot validate as we
-        // don't have the mandatory platform against which to
-        // validate.
+        // Caller requires validation but we cannot validate as we don't
+        // have the mandatory platform against which to validate.
         return llvm::make_error<llvm::StringError>(
             "cannot validate options: no platform available",
             llvm::inconvertibleErrorCode());
Index: source/Interpreter/Property.cpp
===================================================================
--- source/Interpreter/Property.cpp
+++ source/Interpreter/Property.cpp
@@ -32,8 +32,8 @@
     break;
   case OptionValue::eTypeArch:
     // "definition.default_uint_value" is not used
-    // "definition.default_cstr_value" as a string value that represents the
-    // default string value for the architecture/triple
+    // "definition.default_cstr_value" as a string value that represents
+    // the default string value for the architecture/triple
     m_value_sp.reset(new OptionValueArch(definition.default_cstr_value));
     break;
 
@@ -51,8 +51,8 @@
   case OptionValue::eTypeBoolean:
     // "definition.default_uint_value" is the default boolean value if
     // "definition.default_cstr_value" is NULL, otherwise interpret
-    // "definition.default_cstr_value" as a string value that represents the
-    // default value.
+    // "definition.default_cstr_value" as a string value that represents
+    // the default value.
     if (definition.default_cstr_value)
       m_value_sp.reset(new OptionValueBoolean(OptionArgParser::ToBoolean(
           llvm::StringRef(definition.default_cstr_value), false, nullptr)));
@@ -76,9 +76,8 @@
   case OptionValue::eTypeEnum:
     // "definition.default_uint_value" is the default enumeration value if
     // "definition.default_cstr_value" is NULL, otherwise interpret
-    // "definition.default_cstr_value" as a string value that represents the
-    // default
-    // value.
+    // "definition.default_cstr_value" as a string value that represents
+    // the default value.
     {
       OptionValueEnumeration *enum_value = new OptionValueEnumeration(
           definition.enum_values, definition.default_uint_value);
@@ -91,8 +90,8 @@
           enum_value->SetDefaultValue(enum_value->GetCurrentValue());
           // Call Clear() since we don't want the value to appear as
           // having been set since we called SetValueFromString() above.
-          // Clear will set the current value to the default and clear
-          // the boolean that says that the value has been set.
+          // Clear will set the current value to the default and clear the
+          // boolean that says that the value has been set.
           enum_value->Clear();
         }
       }
@@ -101,8 +100,7 @@
 
   case OptionValue::eTypeFileSpec: {
     // "definition.default_uint_value" represents if the
-    // "definition.default_cstr_value" should
-    // be resolved or not
+    // "definition.default_cstr_value" should be resolved or not
     const bool resolve = definition.default_uint_value != 0;
     m_value_sp.reset(new OptionValueFileSpec(
         FileSpec(definition.default_cstr_value, resolve), resolve));
@@ -116,12 +114,10 @@
     break;
 
   case OptionValue::eTypeFormat:
-    // "definition.default_uint_value" is the default format enumeration value
-    // if
-    // "definition.default_cstr_value" is NULL, otherwise interpret
-    // "definition.default_cstr_value" as a string value that represents the
-    // default
-    // value.
+    // "definition.default_uint_value" is the default format enumeration
+    // value if "definition.default_cstr_value" is NULL, otherwise
+    // interpret "definition.default_cstr_value" as a string value that
+    // represents the default value.
     {
       Format new_format = eFormatInvalid;
       if (definition.default_cstr_value)
@@ -134,12 +130,10 @@
     break;
 
   case OptionValue::eTypeLanguage:
-    // "definition.default_uint_value" is the default language enumeration value
-    // if
-    // "definition.default_cstr_value" is NULL, otherwise interpret
-    // "definition.default_cstr_value" as a string value that represents the
-    // default
-    // value.
+    // "definition.default_uint_value" is the default language enumeration
+    // value if "definition.default_cstr_value" is NULL, otherwise
+    // interpret "definition.default_cstr_value" as a string value that
+    // represents the default value.
     {
       LanguageType new_lang = eLanguageTypeUnknown;
       if (definition.default_cstr_value)
@@ -152,33 +146,31 @@
     break;
 
   case OptionValue::eTypeFormatEntity:
-    // "definition.default_cstr_value" as a string value that represents the
-    // default
+    // "definition.default_cstr_value" as a string value that represents
+    // the default
     m_value_sp.reset(
         new OptionValueFormatEntity(definition.default_cstr_value));
     break;
 
   case OptionValue::eTypePathMap:
-    // "definition.default_uint_value" tells us if notifications should occur
-    // for
-    // path mappings
+    // "definition.default_uint_value" tells us if notifications should
+    // occur for path mappings
     m_value_sp.reset(
         new OptionValuePathMappings(definition.default_uint_value != 0));
     break;
 
   case OptionValue::eTypeRegex:
-    // "definition.default_uint_value" is used to the regular expression flags
-    // "definition.default_cstr_value" the default regular expression value
-    // value.
+    // "definition.default_uint_value" is used to the regular expression
+    // flags "definition.default_cstr_value" the default regular
+    // expression value value.
     m_value_sp.reset(new OptionValueRegex(definition.default_cstr_value));
     break;
 
   case OptionValue::eTypeSInt64:
     // "definition.default_uint_value" is the default integer value if
     // "definition.default_cstr_value" is NULL, otherwise interpret
-    // "definition.default_cstr_value" as a string value that represents the
-    // default
-    // value.
+    // "definition.default_cstr_value" as a string value that represents
+    // the default value.
     m_value_sp.reset(new OptionValueSInt64(
         definition.default_cstr_value
             ? StringConvert::ToSInt64(definition.default_cstr_value)
@@ -186,11 +178,10 @@
     break;
 
   case OptionValue::eTypeUInt64:
-    // "definition.default_uint_value" is the default unsigned integer value if
-    // "definition.default_cstr_value" is NULL, otherwise interpret
-    // "definition.default_cstr_value" as a string value that represents the
-    // default
-    // value.
+    // "definition.default_uint_value" is the default unsigned integer
+    // value if "definition.default_cstr_value" is NULL, otherwise
+    // interpret "definition.default_cstr_value" as a string value that
+    // represents the default value.
     m_value_sp.reset(new OptionValueUInt64(
         definition.default_cstr_value
             ? StringConvert::ToUInt64(definition.default_cstr_value)
@@ -198,8 +189,9 @@
     break;
 
   case OptionValue::eTypeUUID:
-    // "definition.default_uint_value" is not used for a OptionValue::eTypeUUID
-    // "definition.default_cstr_value" can contain a default UUID value
+    // "definition.default_uint_value" is not used for a
+    // OptionValue::eTypeUUID "definition.default_cstr_value" can contain
+    // a default UUID value
     {
       UUID uuid;
       if (definition.default_cstr_value)
@@ -209,9 +201,9 @@
     break;
 
   case OptionValue::eTypeString:
-    // "definition.default_uint_value" can contain the string option flags OR'ed
-    // together
-    // "definition.default_cstr_value" can contain a default string value
+    // "definition.default_uint_value" can contain the string option flags
+    // OR'ed together "definition.default_cstr_value" can contain a
+    // default string value
     {
       OptionValueString *string_value =
           new OptionValueString(definition.default_cstr_value);
Index: source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp
===================================================================
--- source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp
+++ source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp
@@ -1301,9 +1301,9 @@
 
 const lldb_private::RegisterInfo *
 ABIMacOSX_arm::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
+  // Make the C-string names and alt_names for the register infos into
+  // const C-string values by having the ConstString unique the names in
+  // the global constant C-string pool.
   if (!g_register_info_names_constified) {
     g_register_info_names_constified = true;
     for (uint32_t i = 0; i < k_num_register_infos; ++i) {
@@ -1404,8 +1404,8 @@
   Address so_addr;
 
   // Figure out if our return address is ARM or Thumb by using the
-  // Address::GetCallableLoadAddress(Target*) which will figure out the ARM
-  // thumb-ness and set the correct address bits for us.
+  // Address::GetCallableLoadAddress(Target*) which will figure out the
+  // ARM thumb-ness and set the correct address bits for us.
   so_addr.SetLoadAddress(return_addr, target_sp.get());
   return_addr = so_addr.GetCallableLoadAddress(target_sp.get());
 
@@ -1413,8 +1413,8 @@
   if (!reg_ctx->WriteRegisterFromUnsigned(ra_reg_num, return_addr))
     return false;
 
-  // If bit zero or 1 is set, this must be a thumb function, no need to figure
-  // this out from the symbols.
+  // If bit zero or 1 is set, this must be a thumb function, no need to
+  // figure this out from the symbols.
   so_addr.SetLoadAddress(function_addr, target_sp.get());
   function_addr = so_addr.GetCallableLoadAddress(target_sp.get());
 
@@ -1453,8 +1453,8 @@
   uint32_t num_values = values.GetSize();
 
   ExecutionContext exe_ctx(thread.shared_from_this());
-  // For now, assume that the types in the AST values come from the Target's
-  // scratch AST.
+  // For now, assume that the types in the AST values come from the
+  // Target's scratch AST.
 
   // Extract the register context so we can read arguments from registers
 
@@ -1482,7 +1482,8 @@
       } else if (compiler_type.IsPointerOrReferenceType()) {
         bit_width = compiler_type.GetBitSize(&thread);
       } else {
-        // We only handle integer, pointer and reference types currently...
+        // We only handle integer, pointer and reference types
+        // currently...
         return false;
       }
 
@@ -1576,8 +1577,8 @@
 
   bool is_signed;
 
-  // Get the pointer to the first stack argument so we have a place to start
-  // when reading data
+  // Get the pointer to the first stack argument so we have a place to
+  // start when reading data
 
   const RegisterInfo *r0_reg_info = reg_ctx->GetRegisterInfoByName("r0", 0);
   if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
@@ -1588,11 +1589,10 @@
       return return_valobj_sp;
     case 128:
       if (IsArmv7kProcess()) {
-        // "A composite type not larger than 16 bytes is returned in r0-r3. The
-        // format is
-        // as if the result had been stored in memory at a word-aligned address
-        // and then
-        // loaded into r0-r3 with an ldm instruction"
+        // "A composite type not larger than 16 bytes is returned in
+        // r0-r3. The format is as if the result had been stored in memory
+        // at a word-aligned address and then loaded into r0-r3 with an
+        // ldm instruction"
         {
           const RegisterInfo *r1_reg_info =
               reg_ctx->GetRegisterInfoByName("r1", 0);
@@ -1694,7 +1694,8 @@
     return return_valobj_sp;
   }
 
-  // If we get here, we have a valid Value, so make our ValueObject out of it:
+  // If we get here, we have a valid Value, so make our ValueObject out of
+  // it:
 
   return_valobj_sp = ValueObjectConstResult::Create(
       thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
@@ -1755,11 +1756,10 @@
         }
       }
     } else if (num_bytes <= 16 && IsArmv7kProcess()) {
-      // "A composite type not larger than 16 bytes is returned in r0-r3. The
-      // format is
-      // as if the result had been stored in memory at a word-aligned address
-      // and then
-      // loaded into r0-r3 with an ldm instruction"
+      // "A composite type not larger than 16 bytes is returned in r0-r3.
+      // The format is as if the result had been stored in memory at a
+      // word-aligned address and then loaded into r0-r3 with an ldm
+      // instruction"
 
       const RegisterInfo *r0_info = reg_ctx->GetRegisterInfoByName("r0", 0);
       const RegisterInfo *r1_info = reg_ctx->GetRegisterInfoByName("r1", 0);
Index: source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp
===================================================================
--- source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp
+++ source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp
@@ -1641,9 +1641,9 @@
 
 const lldb_private::RegisterInfo *
 ABIMacOSX_arm64::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
+  // Make the C-string names and alt_names for the register infos into
+  // const C-string values by having the ConstString unique the names in
+  // the global constant C-string pool.
   if (!g_register_info_names_constified) {
     g_register_info_names_constified = true;
     for (uint32_t i = 0; i < k_num_register_infos; ++i) {
@@ -1776,7 +1776,8 @@
       } else if (value_type.IsPointerOrReferenceType()) {
         bit_width = value_type.GetBitSize(&thread);
       } else {
-        // We only handle integer, pointer and reference types currently...
+        // We only handle integer, pointer and reference types
+        // currently...
         return false;
       }
 
@@ -1892,7 +1893,8 @@
     const uint32_t type_flags = return_value_type.GetTypeInfo(nullptr);
     if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
       if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
-        // Extract the register context so we can read arguments from registers
+        // Extract the register context so we can read arguments from
+        // registers
         lldb::offset_t offset = 0;
         if (byte_size <= 16) {
           const RegisterInfo *x0_info = reg_ctx->GetRegisterInfoByName("x0", 0);
@@ -2022,10 +2024,9 @@
 }
 
 // AAPCS64 (Procedure Call Standard for the ARM 64-bit Architecture) says
-// registers x19 through x28 and sp are callee preserved.
-// v8-v15 are non-volatile (and specifically only the lower 8 bytes of these
-// regs),
-// the rest of the fp/SIMD registers are volatile.
+// registers x19 through x28 and sp are callee preserved. v8-v15 are non-
+// volatile (and specifically only the lower 8 bytes of these regs), the
+// rest of the fp/SIMD registers are volatile.
 
 // We treat x29 as callee preserved also, else the unwinder won't try to
 // retrieve fp saves.
@@ -2034,8 +2035,8 @@
   if (reg_info) {
     const char *name = reg_info->name;
 
-    // Sometimes we'll be called with the "alternate" name for these registers;
-    // recognize them as non-volatile.
+    // Sometimes we'll be called with the "alternate" name for these
+    // registers; recognize them as non-volatile.
 
     if (name[0] == 'p' && name[1] == 'c') // pc
       return false;
@@ -2048,7 +2049,8 @@
 
     if (name[0] == 'x') {
       // Volatile registers: x0-x18, x30 (lr)
-      // Return false for the non-volatile gpr regs, true for everything else
+      // Return false for the non-volatile gpr regs, true for everything
+      // else
       switch (name[1]) {
       case '1':
         switch (name[2]) {
@@ -2084,7 +2086,8 @@
       }
     } else if (name[0] == 'v' || name[0] == 's' || name[0] == 'd') {
       // Volatile registers: v0-7, v16-v31
-      // Return false for non-volatile fp/SIMD regs, true for everything else
+      // Return false for non-volatile fp/SIMD regs, true for everything
+      // else
       switch (name[1]) {
       case '8':
       case '9':
@@ -2210,13 +2213,14 @@
     const RegisterInfo *reg_info = nullptr;
     if (is_return_value) {
       // We are assuming we are decoding this immediately after returning
-      // from a function call and that the address of the structure is in x8
+      // from a function call and that the address of the structure is in
+      // x8
       reg_info = reg_ctx->GetRegisterInfoByName("x8", 0);
     } else {
-      // We are assuming we are stopped at the first instruction in a function
-      // and that the ABI is being respected so all parameters appear where they
-      // should be (functions with no external linkage can legally violate the
-      // ABI).
+      // We are assuming we are stopped at the first instruction in a
+      // function and that the ABI is being respected so all parameters
+      // appear where they should be (functions with no external linkage
+      // can legally violate the ABI).
       if (NGRN >= 8)
         return false;
 
@@ -2261,7 +2265,8 @@
   if (exe_ctx.GetTargetPtr() == nullptr || exe_ctx.GetProcessPtr() == nullptr)
     return return_valobj_sp;
 
-  // value.SetContext (Value::eContextTypeClangType, return_compiler_type);
+  // value.SetContext (Value::eContextTypeClangType,
+  // return_compiler_type);
   value.SetCompilerType(return_compiler_type);
 
   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
@@ -2276,7 +2281,8 @@
 
     bool success = false;
     if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
-      // Extract the register context so we can read arguments from registers
+      // Extract the register context so we can read arguments from
+      // registers
       if (byte_size <= 8) {
         const RegisterInfo *x0_reg_info =
             reg_ctx->GetRegisterInfoByName("x0", 0);
Index: source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp
===================================================================
--- source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp
+++ source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp
@@ -688,9 +688,9 @@
 
 const lldb_private::RegisterInfo *
 ABIMacOSX_i386::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
+  // Make the C-string names and alt_names for the register infos into
+  // const C-string values by having the ConstString unique the names in
+  // the global constant C-string pool.
   if (!g_register_info_names_constified) {
     g_register_info_names_constified = true;
     for (uint32_t i = 0; i < k_num_register_infos; ++i) {
@@ -737,9 +737,9 @@
       eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
 
   // When writing a register value down to memory, the register info used
-  // to write memory just needs to have the correct size of a 32 bit register,
-  // the actual register it pertains to is not important, just the size needs
-  // to be correct. Here we use "eax"...
+  // to write memory just needs to have the correct size of a 32 bit
+  // register, the actual register it pertains to is not important, just
+  // the size needs to be correct. Here we use "eax"...
   const RegisterInfo *reg_info_32 = reg_ctx->GetRegisterInfoByName("eax");
   if (!reg_info_32)
     return false; // TODO this should actually never happen
@@ -766,8 +766,8 @@
     arg_pos += 4;
   }
 
-  // The return address is pushed onto the stack (yes after we just set the
-  // alignment above!).
+  // The return address is pushed onto the stack (yes after we just set
+  // the alignment above!).
   sp -= 4;
   reg_value.SetUInt32(return_addr);
   error = reg_ctx->WriteRegisterValueToMemory(
@@ -807,8 +807,8 @@
   unsigned int num_values = values.GetSize();
   unsigned int value_index;
 
-  // Get the pointer to the first stack argument so we have a place to start
-  // when reading data
+  // Get the pointer to the first stack argument so we have a place to
+  // start when reading data
 
   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
 
@@ -1012,7 +1012,8 @@
     return return_valobj_sp;
   }
 
-  // If we get here, we have a valid Value, so make our ValueObject out of it:
+  // If we get here, we have a valid Value, so make our ValueObject out of
+  // it:
 
   return_valobj_sp = ValueObjectConstResult::Create(
       thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
@@ -1075,12 +1076,13 @@
 }
 
 // v.
-// http://developer.apple.com/library/mac/#documentation/developertools/Conceptual/LowLevelABI/130-IA-32_Function_Calling_Conventions/IA32.html#//apple_ref/doc/uid/TP40002492-SW4
+// http://developer.apple.com/library/mac/#documentation/developertools/Conceptual/LowLevelABI/130
+// -IA-
+// 32_Function_Calling_Conventions/IA32.html#//apple_ref/doc/uid/TP40002492-SW4
 //
 // This document ("OS X ABI Function Call Guide", chapter "IA-32 Function
-// Calling Conventions")
-// says that the following registers on i386 are preserved aka non-volatile aka
-// callee-saved:
+// Calling Conventions") says that the following registers on i386 are
+// preserved aka non-volatile aka callee-saved:
 //
 // ebx, ebp, esi, edi, esp
 
Index: source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp
===================================================================
--- source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp
+++ source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp
@@ -1302,9 +1302,9 @@
 
 const lldb_private::RegisterInfo *
 ABISysV_arm::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
+  // Make the C-string names and alt_names for the register infos into
+  // const C-string values by having the ConstString unique the names in
+  // the global constant C-string pool.
   if (!g_register_info_names_constified) {
     g_register_info_names_constified = true;
     for (uint32_t i = 0; i < k_num_register_infos; ++i) {
@@ -1408,8 +1408,8 @@
   Address so_addr;
 
   // Figure out if our return address is ARM or Thumb by using the
-  // Address::GetCallableLoadAddress(Target*) which will figure out the ARM
-  // thumb-ness and set the correct address bits for us.
+  // Address::GetCallableLoadAddress(Target*) which will figure out the
+  // ARM thumb-ness and set the correct address bits for us.
   so_addr.SetLoadAddress(return_addr, target_sp.get());
   return_addr = so_addr.GetCallableLoadAddress(target_sp.get());
 
@@ -1421,8 +1421,8 @@
   if (!reg_ctx->WriteRegisterFromUnsigned(sp_reg_num, sp))
     return false;
 
-  // If bit zero or 1 is set, this must be a thumb function, no need to figure
-  // this out from the symbols.
+  // If bit zero or 1 is set, this must be a thumb function, no need to
+  // figure this out from the symbols.
   so_addr.SetLoadAddress(function_addr, target_sp.get());
   function_addr = so_addr.GetCallableLoadAddress(target_sp.get());
 
@@ -1457,8 +1457,8 @@
   uint32_t num_values = values.GetSize();
 
   ExecutionContext exe_ctx(thread.shared_from_this());
-  // For now, assume that the types in the AST values come from the Target's
-  // scratch AST.
+  // For now, assume that the types in the AST values come from the
+  // Target's scratch AST.
 
   // Extract the register context so we can read arguments from registers
 
@@ -1486,7 +1486,8 @@
       } else if (compiler_type.IsPointerOrReferenceType()) {
         bit_width = compiler_type.GetBitSize(&thread);
       } else {
-        // We only handle integer, pointer and reference types currently...
+        // We only handle integer, pointer and reference types
+        // currently...
         return false;
       }
 
@@ -1585,8 +1586,8 @@
   uint8_t vfp_count = 0;
   uint8_t vfp_byte_size = 0;
 
-  // Get the pointer to the first stack argument so we have a place to start
-  // when reading data
+  // Get the pointer to the first stack argument so we have a place to
+  // start when reading data
 
   const RegisterInfo *r0_reg_info =
       reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
@@ -1839,7 +1840,8 @@
     }
   }
 
-  // If we get here, we have a valid Value, so make our ValueObject out of it:
+  // If we get here, we have a valid Value, so make our ValueObject out of
+  // it:
 
   return_valobj_sp = ValueObjectConstResult::Create(
       thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
Index: source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp
===================================================================
--- source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp
+++ source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp
@@ -1640,9 +1640,9 @@
 
 const lldb_private::RegisterInfo *
 ABISysV_arm64::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
+  // Make the C-string names and alt_names for the register infos into
+  // const C-string values by having the ConstString unique the names in
+  // the global constant C-string pool.
   if (!g_register_info_names_constified) {
     g_register_info_names_constified = true;
     for (uint32_t i = 0; i < k_num_register_infos; ++i) {
@@ -1779,7 +1779,8 @@
       } else if (value_type.IsPointerOrReferenceType()) {
         bit_width = value_type.GetBitSize(&thread);
       } else {
-        // We only handle integer, pointer and reference types currently...
+        // We only handle integer, pointer and reference types
+        // currently...
         return false;
       }
 
@@ -1864,7 +1865,8 @@
     const uint32_t type_flags = return_value_type.GetTypeInfo(nullptr);
     if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
       if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
-        // Extract the register context so we can read arguments from registers
+        // Extract the register context so we can read arguments from
+        // registers
         lldb::offset_t offset = 0;
         if (byte_size <= 16) {
           const RegisterInfo *x0_info = reg_ctx->GetRegisterInfo(
@@ -1994,10 +1996,9 @@
 }
 
 // AAPCS64 (Procedure Call Standard for the ARM 64-bit Architecture) says
-// registers x19 through x28 and sp are callee preserved.
-// v8-v15 are non-volatile (and specifically only the lower 8 bytes of these
-// regs),
-// the rest of the fp/SIMD registers are volatile.
+// registers x19 through x28 and sp are callee preserved. v8-v15 are non-
+// volatile (and specifically only the lower 8 bytes of these regs), the
+// rest of the fp/SIMD registers are volatile.
 
 // We treat x29 as callee preserved also, else the unwinder won't try to
 // retrieve fp saves.
@@ -2006,8 +2007,8 @@
   if (reg_info) {
     const char *name = reg_info->name;
 
-    // Sometimes we'll be called with the "alternate" name for these registers;
-    // recognize them as non-volatile.
+    // Sometimes we'll be called with the "alternate" name for these
+    // registers; recognize them as non-volatile.
 
     if (name[0] == 'p' && name[1] == 'c') // pc
       return false;
@@ -2020,10 +2021,10 @@
 
     if (name[0] == 'x' || name[0] == 'r') {
       // Volatile registers: x0-x18
-      // Although documentation says only x19-28 + sp are callee saved
-      // We ll also have to treat x30 as non-volatile.
-      // Each dwarf frame has its own value of lr.
-      // Return false for the non-volatile gpr regs, true for everything else
+      // Although documentation says only x19-28 + sp are callee saved We
+      // ll also have to treat x30 as non-volatile. Each dwarf frame has
+      // its own value of lr. Return false for the non-volatile gpr regs,
+      // true for everything else
       switch (name[1]) {
       case '1':
         switch (name[2]) {
@@ -2059,7 +2060,8 @@
       }
     } else if (name[0] == 'v' || name[0] == 's' || name[0] == 'd') {
       // Volatile registers: v0-7, v16-v31
-      // Return false for non-volatile fp/SIMD regs, true for everything else
+      // Return false for non-volatile fp/SIMD regs, true for everything
+      // else
       switch (name[1]) {
       case '8':
       case '9':
@@ -2181,13 +2183,14 @@
     const RegisterInfo *reg_info = nullptr;
     if (is_return_value) {
       // We are assuming we are decoding this immediately after returning
-      // from a function call and that the address of the structure is in x8
+      // from a function call and that the address of the structure is in
+      // x8
       reg_info = reg_ctx->GetRegisterInfoByName("x8", 0);
     } else {
-      // We are assuming we are stopped at the first instruction in a function
-      // and that the ABI is being respected so all parameters appear where they
-      // should be (functions with no external linkage can legally violate the
-      // ABI).
+      // We are assuming we are stopped at the first instruction in a
+      // function and that the ABI is being respected so all parameters
+      // appear where they should be (functions with no external linkage
+      // can legally violate the ABI).
       if (NGRN >= 8)
         return false;
 
@@ -2229,7 +2232,8 @@
   if (exe_ctx.GetTargetPtr() == nullptr || exe_ctx.GetProcessPtr() == nullptr)
     return return_valobj_sp;
 
-  // value.SetContext (Value::eContextTypeClangType, return_compiler_type);
+  // value.SetContext (Value::eContextTypeClangType,
+  // return_compiler_type);
   value.SetCompilerType(return_compiler_type);
 
   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
@@ -2244,7 +2248,8 @@
 
     bool success = false;
     if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
-      // Extract the register context so we can read arguments from registers
+      // Extract the register context so we can read arguments from
+      // registers
       if (byte_size <= 8) {
         const RegisterInfo *x0_reg_info = nullptr;
         x0_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
Index: source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp
===================================================================
--- source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp
+++ source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp
@@ -981,9 +981,9 @@
 
 const lldb_private::RegisterInfo *
 ABISysV_hexagon::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
+  // Make the C-string names and alt_names for the register infos into
+  // const C-string values by having the ConstString unique the names in
+  // the global constant C-string pool.
   if (!g_register_info_names_constified) {
     g_register_info_names_constified = true;
     for (uint32_t i = 0; i < k_num_register_infos; ++i) {
@@ -1115,8 +1115,8 @@
     if (error.Fail())
       return false;
 
-    // update the argument with the target pointer
-    // XXX: This is a gross hack for getting around the const
+    // update the argument with the target pointer XXX: This is a gross
+    // hack for getting around the const
     *const_cast<lldb::addr_t *>(&arg.value) = sp;
   }
 
@@ -1214,8 +1214,8 @@
   return return_valobj_sp;
 }
 
-// called when we are on the first instruction of a new function
-// for hexagon the return address is in RA (R31)
+// called when we are on the first instruction of a new function for
+// hexagon the return address is in RA (R31)
 bool ABISysV_hexagon::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
   unwind_plan.Clear();
   unwind_plan.SetRegisterKind(eRegisterKindGeneric);
Index: source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp
===================================================================
--- source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp
+++ source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp
@@ -3,8 +3,7 @@
 //                   The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
-// License.
-// See LICENSE.TXT for details.
+// License. See LICENSE.TXT for details.
 //===----------------------------------------------------------------------===//
 
 #include "ABISysV_i386.h"
@@ -55,9 +54,9 @@
 //====================================================================
 
 // DWARF Register Number Mapping
-// See Table 2.14 of the reference document (specified on top of this file)
-// Comment: Table 2.14 is followed till 'mm' entries.
-// After that, all entries are ignored here.
+// See Table 2.14 of the reference document (specified on top of this
+// file) Comment: Table 2.14 is followed till 'mm' entries. After that,
+// all entries are ignored here.
 
 enum dwarf_regnums {
   dwarf_eax = 0,
@@ -180,9 +179,9 @@
 
 const lldb_private::RegisterInfo *
 ABISysV_i386::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
+  // Make the C-string names and alt_names for the register infos into
+  // const C-string values by having the ConstString unique the names in
+  // the global constant C-string pool.
   if (!g_register_info_names_constified) {
     g_register_info_names_constified = true;
     for (uint32_t i = 0; i < k_num_register_infos; ++i) {
@@ -228,12 +227,10 @@
   uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
       eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
 
-  // While using register info to write a register value to memory, the register
-  // info
-  // just needs to have the correct size of a 32 bit register, the actual
-  // register it
-  // pertains to is not important, just the size needs to be correct.
-  // "eax" is used here for this purpose.
+  // While using register info to write a register value to memory, the
+  // register info just needs to have the correct size of a 32 bit
+  // register, the actual register it pertains to is not important, just
+  // the size needs to be correct. "eax" is used here for this purpose.
   const RegisterInfo *reg_info_32 = reg_ctx->GetRegisterInfoByName("eax");
   if (!reg_info_32)
     return false; // TODO this should actually never happen
@@ -363,9 +360,10 @@
     return error;
   }
 
-  // Following "IF ELSE" block categorizes various 'Fundamental Data Types'.
-  // The terminology 'Fundamental Data Types' used here is adopted from
-  // Table 2.1 of the reference document (specified on top of this file)
+  // Following "IF ELSE" block categorizes various 'Fundamental Data
+  // Types'. The terminology 'Fundamental Data Types' used here is adopted
+  // from Table 2.1 of the reference document (specified on top of this
+  // file)
 
   if (type_flags & eTypeIsPointer) // 'Pointer'
   {
@@ -390,8 +388,8 @@
       default:
         break;
       case 16:
-        // For clang::BuiltinType::UInt128 & Int128
-        // ToDo: Need to decide how to handle it
+        // For clang::BuiltinType::UInt128 & Int128 ToDo: Need to decide
+        // how to handle it
         break;
       case 8: {
         uint32_t raw_value_low = data.GetMaxU32(&offset, 4);
@@ -507,9 +505,10 @@
   unsigned edx_id =
       reg_ctx->GetRegisterInfoByName("edx", 0)->kinds[eRegisterKindLLDB];
 
-  // Following "IF ELSE" block categorizes various 'Fundamental Data Types'.
-  // The terminology 'Fundamental Data Types' used here is adopted from
-  // Table 2.1 of the reference document (specified on top of this file)
+  // Following "IF ELSE" block categorizes various 'Fundamental Data
+  // Types'. The terminology 'Fundamental Data Types' used here is adopted
+  // from Table 2.1 of the reference document (specified on top of this
+  // file)
 
   if (type_flags & eTypeIsPointer) // 'Pointer'
   {
@@ -543,8 +542,8 @@
         break;
 
       case 16:
-        // For clang::BuiltinType::UInt128 & Int128
-        // ToDo: Need to decide how to handle it
+        // For clang::BuiltinType::UInt128 & Int128 ToDo: Need to decide
+        // how to handle it
         break;
 
       case 8:
@@ -612,8 +611,8 @@
               success = true;
             } else if (byte_size == 8) // double is 8 bytes
             {
-              // On Android Platform: long double is also 8 bytes
-              // It will be handled here only.
+              // On Android Platform: long double is also 8 bytes It will
+              // be handled here only.
               double value_double = (double)value_long_double;
               value.GetScalar() = value_double;
               success = true;
@@ -639,8 +638,8 @@
       }
     } else // Neither 'Integral' nor 'Floating Point'
     {
-      // If flow reaches here then check type_flags
-      // This type_flags is unhandled
+      // If flow reaches here then check type_flags This type_flags is
+      // unhandled
     }
   } else if (type_flags & eTypeIsComplex) // 'Complex Floating Point'
   {
Index: source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp
===================================================================
--- source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp
+++ source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp
@@ -698,8 +698,8 @@
   if (log)
     log->Printf("Writing r25: 0x%" PRIx64, (uint64_t)func_addr);
 
-  // All callers of position independent functions must place the address of the
-  // called function in t9 (r25)
+  // All callers of position independent functions must place the address
+  // of the called function in t9 (r25)
   if (!reg_ctx->WriteRegisterFromUnsigned(r25_info, func_addr))
     return false;
 
@@ -867,8 +867,8 @@
         UINT32_MAX;
     value.GetScalar() = ptr;
   } else if (return_compiler_type.IsAggregateType()) {
-    // Structure/Vector is always passed in memory and pointer to that memory is
-    // passed in r2.
+    // Structure/Vector is always passed in memory and pointer to that
+    // memory is passed in r2.
     uint64_t mem_address = reg_ctx->ReadRegisterAsUnsigned(
         reg_ctx->GetRegisterInfoByName("r2", 0), 0);
     // We have got the address. Create a memory object out of it
@@ -963,7 +963,8 @@
     return return_valobj_sp;
   }
 
-  // If we get here, we have a valid Value, so make our ValueObject out of it:
+  // If we get here, we have a valid Value, so make our ValueObject out of
+  // it:
 
   return_valobj_sp = ValueObjectConstResult::Create(
       thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
Index: source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp
===================================================================
--- source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp
+++ source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp
@@ -661,8 +661,8 @@
   if (log)
     log->Printf("Writing r25: 0x%" PRIx64, (uint64_t)func_addr);
 
-  // All callers of position independent functions must place the address of the
-  // called function in t9 (r25)
+  // All callers of position independent functions must place the address
+  // of the called function in t9 (r25)
   if (!reg_ctx->WriteRegisterFromUnsigned(r25_info, func_addr))
     return false;
 
@@ -782,8 +782,9 @@
 
     bool success = false;
     if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
-      // Extract the register context so we can read arguments from registers
-      // In MIPS register "r2" (v0) holds the integer function return values
+      // Extract the register context so we can read arguments from
+      // registers In MIPS register "r2" (v0) holds the integer function
+      // return values
 
       uint64_t raw_value = reg_ctx->ReadRegisterAsUnsigned(r2_info, 0);
 
@@ -916,14 +917,16 @@
           thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
   } else if (type_flags & eTypeIsStructUnion || type_flags & eTypeIsClass ||
              type_flags & eTypeIsVector) {
-    // Any structure of up to 16 bytes in size is returned in the registers.
+    // Any structure of up to 16 bytes in size is returned in the
+    // registers.
     if (byte_size <= 16) {
       DataBufferSP data_sp(new DataBufferHeap(16, 0));
       DataExtractor return_ext(data_sp, target_byte_order,
                                target->GetArchitecture().GetAddressByteSize());
 
       RegisterValue r2_value, r3_value, f0_value, f1_value, f2_value;
-      // Tracks how much bytes of r2 and r3 registers we've consumed so far
+      // Tracks how much bytes of r2 and r3 registers we've consumed so
+      // far
       uint32_t integer_bytes = 0;
 
       // True if return values are in FP return registers.
@@ -941,8 +944,9 @@
       uint32_t count;
       const uint32_t num_children = return_compiler_type.GetNumFields();
 
-      // A structure consisting of one or two FP values (and nothing else) will
-      // be returned in the two FP return-value registers i.e fp0 and fp2.
+      // A structure consisting of one or two FP values (and nothing else)
+      // will be returned in the two FP return-value registers i.e fp0 and
+      // fp2.
       if (num_children <= 2) {
         uint64_t field_bit_offset = 0;
 
@@ -959,8 +963,8 @@
         }
 
         if (use_fp_regs && !found_non_fp_field) {
-          // We have one or two FP-only values in this structure. Get it from
-          // f0/f2 registers.
+          // We have one or two FP-only values in this structure. Get it
+          // from f0/f2 registers.
           DataExtractor f0_data, f1_data, f2_data;
           const RegisterInfo *f0_info = reg_ctx->GetRegisterInfoByName("f0", 0);
           const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0);
@@ -986,8 +990,8 @@
               // This case is for long double type.
               if (field_byte_width == 16) {
 
-                // If structure contains long double type, then it is returned
-                // in fp0/fp1 registers.
+                // If structure contains long double type, then it is
+                // returned in fp0/fp1 registers.
                 if (target_byte_order == eByteOrderLittle) {
                   return_value[0] = f0_data.GetU64(&offset);
                   reg_ctx->ReadRegister(f1_info, f1_value);
@@ -1026,8 +1030,8 @@
                 target_byte_order);
           }
 
-          // The result is in our data buffer.  Create a variable object out of
-          // it
+          // The result is in our data buffer.  Create a variable object
+          // out of it
           return_valobj_sp = ValueObjectConstResult::Create(
               &thread, return_compiler_type, ConstString(""), return_ext);
 
@@ -1035,10 +1039,10 @@
         }
       }
 
-      // If we reach here, it means this structure either contains more than two
-      // fields or
-      // it contains at least one non floating point type.
-      // In that case, all fields are returned in GP return registers.
+      // If we reach here, it means this structure either contains more
+      // than two fields or it contains at least one non floating point
+      // type. In that case, all fields are returned in GP return
+      // registers.
       for (uint32_t idx = 0; idx < num_children; idx++) {
         uint64_t field_bit_offset = 0;
         bool is_signed;
@@ -1049,8 +1053,8 @@
         const size_t field_byte_width =
             field_compiler_type.GetByteSize(nullptr);
 
-        // if we don't know the size of the field (e.g. invalid type), just bail
-        // out
+        // if we don't know the size of the field (e.g. invalid type),
+        // just bail out
         if (field_byte_width == 0)
           break;
 
@@ -1064,30 +1068,30 @@
           if (integer_bytes < 8) {
             // We have not yet consumed r2 completely.
             if (integer_bytes + field_byte_width + padding <= 8) {
-              // This field fits in r2, copy its value from r2 to our result
-              // structure
+              // This field fits in r2, copy its value from r2 to our
+              // result structure
               integer_bytes = integer_bytes + field_byte_width +
                               padding; // Increase the consumed bytes.
               use_r2 = 1;
             } else {
-              // There isn't enough space left in r2 for this field, so this
-              // will be in r3.
+              // There isn't enough space left in r2 for this field, so
+              // this will be in r3.
               integer_bytes = integer_bytes + field_byte_width +
                               padding; // Increase the consumed bytes.
               use_r3 = 1;
             }
           }
-          // We already have consumed at-least 8 bytes that means r2 is done,
-          // and this field will be in r3.
-          // Check if this field can fit in r3.
+          // We already have consumed at-least 8 bytes that means r2 is
+          // done, and this field will be in r3. Check if this field can
+          // fit in r3.
           else if (integer_bytes + field_byte_width + padding <= 16) {
             integer_bytes = integer_bytes + field_byte_width + padding;
             use_r3 = 1;
           } else {
-            // There isn't any space left for this field, this should not happen
-            // as we have already checked
-            // the overall size is not greater than 16 bytes. For now, return a
-            // nullptr return value object.
+            // There isn't any space left for this field, this should not
+            // happen as we have already checked the overall size is not
+            // greater than 16 bytes. For now, return a nullptr return
+            // value object.
             return return_valobj_sp;
           }
         }
@@ -1123,15 +1127,16 @@
         sucess = 1;
       }
       if (sucess) {
-        // The result is in our data buffer.  Create a variable object out of it
+        // The result is in our data buffer.  Create a variable object out
+        // of it
         return_valobj_sp = ValueObjectConstResult::Create(
             &thread, return_compiler_type, ConstString(""), return_ext);
       }
       return return_valobj_sp;
     }
 
-    // Any structure/vector greater than 16 bytes in size is returned in memory.
-    // The pointer to that memory is returned in r2.
+    // Any structure/vector greater than 16 bytes in size is returned in
+    // memory. The pointer to that memory is returned in r2.
     uint64_t mem_address = reg_ctx->ReadRegisterAsUnsigned(
         reg_ctx->GetRegisterInfoByName("r2", 0), 0);
 
Index: source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp
===================================================================
--- source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp
+++ source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp
@@ -111,7 +111,8 @@
   dwarf_cfa,
 };
 
-// Note that the size and offset will be updated by platform-specific classes.
+// Note that the size and offset will be updated by platform-specific
+// classes.
 #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)                       \
   {                                                                            \
     #reg, alt, 8, 0, eEncodingUint, eFormatHex, {kind1, kind2, kind3, kind4 }, \
@@ -119,8 +120,8 @@
   }
 
 static const RegisterInfo g_register_infos[] = {
-    // General purpose registers.             eh_frame,                 DWARF,
-    // Generic,    Process Plugin
+    // General purpose registers.             eh_frame,
+    // DWARF, Generic,    Process Plugin
     DEFINE_GPR(r0, nullptr, dwarf_r0, dwarf_r0, LLDB_INVALID_REGNUM,
                LLDB_INVALID_REGNUM),
     DEFINE_GPR(r1, "sp", dwarf_r1, dwarf_r1, LLDB_REGNUM_GENERIC_SP,
@@ -357,8 +358,8 @@
   if (!reg_ctx)
     return false;
 
-  // Get the pointer to the first stack argument so we have a place to start
-  // when reading data
+  // Get the pointer to the first stack argument so we have a place to
+  // start when reading data
 
   addr_t sp = reg_ctx->GetSP(0);
 
@@ -500,9 +501,9 @@
   }
 
   if (!set_it_simple) {
-    // Okay we've got a structure or something that doesn't fit in a simple
-    // register.
-    // We should figure out where it really goes, but we don't support this yet.
+    // Okay we've got a structure or something that doesn't fit in a
+    // simple register. We should figure out where it really goes, but we
+    // don't support this yet.
     error.SetErrorString("We only support setting simple integer and float "
                          "return types at present.");
   }
@@ -531,7 +532,8 @@
 
     bool success = false;
     if (type_flags & eTypeIsInteger) {
-      // Extract the register context so we can read arguments from registers
+      // Extract the register context so we can read arguments from
+      // registers
 
       const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
       uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
@@ -689,7 +691,8 @@
 
       const uint32_t num_children = return_compiler_type.GetNumFields();
 
-      // Since we are in the small struct regime, assume we are not in memory.
+      // Since we are in the small struct regime, assume we are not in
+      // memory.
       is_memory = false;
 
       for (uint32_t idx = 0; idx < num_children; idx++) {
@@ -719,7 +722,8 @@
             field_compiler_type.IsPointerType()) {
           if (integer_bytes < 8) {
             if (integer_bytes + field_byte_width <= 8) {
-              // This is in RAX, copy from register to our result structure:
+              // This is in RAX, copy from register to our result
+              // structure:
               copy_from_extractor = &r3_data;
               copy_from_offset = integer_bytes;
               integer_bytes += field_byte_width;
@@ -735,10 +739,9 @@
             copy_from_offset = integer_bytes - 8;
             integer_bytes += field_byte_width;
           } else {
-            // The last field didn't fit.  I can't see how that would happen w/o
-            // the overall size being
-            // greater than 16 bytes.  For now, return a nullptr return value
-            // object.
+            // The last field didn't fit.  I can't see how that would
+            // happen w/o the overall size being greater than 16 bytes.
+            // For now, return a nullptr return value object.
             return return_valobj_sp;
           }
         } else if (field_compiler_type.IsFloatingPointType(count, is_complex)) {
@@ -750,15 +753,15 @@
             copy_from_offset = 0;
             fp_bytes += field_byte_width;
           } else if (field_bit_width == 32) {
-            // This one is kind of complicated.  If we are in an "eightbyte"
-            // with another float, we'll
-            // be stuffed into an xmm register with it.  If we are in an
-            // "eightbyte" with one or more ints,
-            // then we will be stuffed into the appropriate GPR with them.
+            // This one is kind of complicated.  If we are in an
+            // "eightbyte" with another float, we'll be stuffed into an
+            // xmm register with it.  If we are in an "eightbyte" with one
+            // or more ints, then we will be stuffed into the appropriate
+            // GPR with them.
             bool in_gpr;
             if (field_byte_offset % 8 == 0) {
-              // We are at the beginning of one of the eightbytes, so check the
-              // next element (if any)
+              // We are at the beginning of one of the eightbytes, so
+              // check the next element (if any)
               if (idx == num_children - 1)
                 in_gpr = false;
               else {
@@ -776,9 +779,9 @@
                 }
               }
             } else if (field_byte_offset % 4 == 0) {
-              // We are inside of an eightbyte, so see if the field before us is
-              // floating point:
-              // This could happen if somebody put padding in the structure.
+              // We are inside of an eightbyte, so see if the field before
+              // us is floating point: This could happen if somebody put
+              // padding in the structure.
               if (idx == 0)
                 in_gpr = false;
               else {
@@ -800,11 +803,12 @@
               continue;
             }
 
-            // Okay, we've figured out whether we are in GPR or XMM, now figure
-            // out which one.
+            // Okay, we've figured out whether we are in GPR or XMM, now
+            // figure out which one.
             if (in_gpr) {
               if (integer_bytes < 8) {
-                // This is in RAX, copy from register to our result structure:
+                // This is in RAX, copy from register to our result
+                // structure:
                 copy_from_extractor = &r3_data;
                 copy_from_offset = integer_bytes;
                 integer_bytes += field_byte_width;
@@ -820,8 +824,8 @@
         }
 
         // These two tests are just sanity checks.  If I somehow get the
-        // type calculation wrong above it is better to just return nothing
-        // than to assert or crash.
+        // type calculation wrong above it is better to just return
+        // nothing than to assert or crash.
         if (!copy_from_extractor)
           return return_valobj_sp;
         if (copy_from_offset + field_byte_width >
@@ -835,20 +839,19 @@
       }
 
       if (!is_memory) {
-        // The result is in our data buffer.  Let's make a variable object out
-        // of it:
+        // The result is in our data buffer.  Let's make a variable object
+        // out of it:
         return_valobj_sp = ValueObjectConstResult::Create(
             &thread, return_compiler_type, ConstString(""), return_ext);
       }
     }
 
-    // FIXME: This is just taking a guess, r3 may very well no longer hold the
-    // return storage location.
-    // If we are going to do this right, when we make a new frame we should
-    // check to see if it uses a memory
-    // return, and if we are at the first instruction and if so stash away the
-    // return location.  Then we would
-    // only return the memory return value if we know it is valid.
+    // FIXME: This is just taking a guess, r3 may very well no longer hold
+    // the return storage location. If we are going to do this right, when
+    // we make a new frame we should check to see if it uses a memory
+    // return, and if we are at the first instruction and if so stash away
+    // the return location.  Then we would only return the memory return
+    // value if we know it is valid.
 
     if (is_memory) {
       unsigned r3_id =
@@ -918,8 +921,8 @@
 
 // See "Register Usage" in the
 // "System V Application Binary Interface"
-// "64-bit PowerPC ELF Application Binary Interface Supplement"
-// current version is 1.9 released 2004 at
+// "64-bit PowerPC ELF Application Binary Interface Supplement" current
+// version is 1.9 released 2004 at
 // http://refspecs.linuxfoundation.org/ELF/ppc/PPC-elf64abi-1.9.pdf
 
 bool ABISysV_ppc::RegisterIsCalleeSaved(const RegisterInfo *reg_info) {
Index: source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp
===================================================================
--- source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp
+++ source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp
@@ -247,8 +247,8 @@
   if (!reg_ctx)
     return false;
 
-  // Get the pointer to the first stack argument so we have a place to start
-  // when reading data
+  // Get the pointer to the first stack argument so we have a place to
+  // start when reading data
 
   addr_t sp = reg_ctx->GetSP(0);
 
@@ -379,9 +379,9 @@
   }
 
   if (!set_it_simple) {
-    // Okay we've got a structure or something that doesn't fit in a simple
-    // register.
-    // We should figure out where it really goes, but we don't support this yet.
+    // Okay we've got a structure or something that doesn't fit in a
+    // simple register. We should figure out where it really goes, but we
+    // don't support this yet.
     error.SetErrorString("We only support setting simple integer and float "
                          "return types at present.");
   }
@@ -402,8 +402,8 @@
   //
   // It may be constructed by directly specifying its index (where 0 is
   // the first register used to return values) or by specifying the offset
-  // of a given struct field, in which case the appropriated register index
-  // will be calculated.
+  // of a given struct field, in which case the appropriated register
+  // index will be calculated.
   class Register {
   public:
     enum Type {
@@ -720,8 +720,8 @@
       }
     }
 
-    // Get the whole contents of vector registers and let the
-    // logic here arrange the data properly.
+    // Get the whole contents of vector registers and let the logic here
+    // arrange the data properly.
 
     RegisterValue vr_val[MAX_VRS];
     Status error;
@@ -741,8 +741,8 @@
     }
 
     // The compiler generated code seems to always put the vector elements
-    // at the end of the vector register, in case they don't occupy all of it.
-    // This offset variable handles this.
+    // at the end of the vector register, in case they don't occupy all of
+    // it. This offset variable handles this.
     uint32_t offs = 0;
     if (m_byte_size < vr_size)
       offs = vr_size - m_byte_size;
@@ -1025,8 +1025,8 @@
 
 // See "Register Usage" in the
 // "System V Application Binary Interface"
-// "64-bit PowerPC ELF Application Binary Interface Supplement"
-// current version is 2 released 2015 at
+// "64-bit PowerPC ELF Application Binary Interface Supplement" current
+// version is 2 released 2015 at
 // https://members.openpowerfoundation.org/document/dl/576
 bool ABISysV_ppc64::RegisterIsCalleeSaved(const RegisterInfo *reg_info) {
   if (reg_info) {
Index: source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp
===================================================================
--- source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp
+++ source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp
@@ -180,9 +180,9 @@
 
 const lldb_private::RegisterInfo *
 ABISysV_s390x::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
+  // Make the C-string names and alt_names for the register infos into
+  // const C-string values by having the ConstString unique the names in
+  // the global constant C-string pool.
   if (!g_register_info_names_constified) {
     g_register_info_names_constified = true;
     for (uint32_t i = 0; i < k_num_register_infos; ++i) {
@@ -344,8 +344,8 @@
   if (!reg_ctx)
     return false;
 
-  // Get the pointer to the first stack argument so we have a place to start
-  // when reading data
+  // Get the pointer to the first stack argument so we have a place to
+  // start when reading data
 
   addr_t sp = reg_ctx->GetSP(0);
 
@@ -482,9 +482,9 @@
   }
 
   if (!set_it_simple) {
-    // Okay we've got a structure or something that doesn't fit in a simple
-    // register.
-    // We should figure out where it really goes, but we don't support this yet.
+    // Okay we've got a structure or something that doesn't fit in a
+    // simple register. We should figure out where it really goes, but we
+    // don't support this yet.
     error.SetErrorString("We only support setting simple integer and float "
                          "return types at present.");
   }
@@ -513,7 +513,8 @@
 
     bool success = false;
     if (type_flags & eTypeIsInteger) {
-      // Extract the register context so we can read arguments from registers
+      // Extract the register context so we can read arguments from
+      // registers
 
       const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
       uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
@@ -615,13 +616,12 @@
     return return_valobj_sp;
 
   if (return_compiler_type.IsAggregateType()) {
-    // FIXME: This is just taking a guess, r2 may very well no longer hold the
-    // return storage location.
-    // If we are going to do this right, when we make a new frame we should
-    // check to see if it uses a memory
-    // return, and if we are at the first instruction and if so stash away the
-    // return location.  Then we would
-    // only return the memory return value if we know it is valid.
+    // FIXME: This is just taking a guess, r2 may very well no longer hold
+    // the return storage location. If we are going to do this right, when
+    // we make a new frame we should check to see if it uses a memory
+    // return, and if we are at the first instruction and if so stash away
+    // the return location.  Then we would only return the memory return
+    // value if we know it is valid.
 
     unsigned r2_id =
         reg_ctx_sp->GetRegisterInfoByName("r2", 0)->kinds[eRegisterKindLLDB];
@@ -654,17 +654,17 @@
 }
 
 bool ABISysV_s390x::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
-  // There's really no default way to unwind on s390x.
-  // Trust the .eh_frame CFI, which should always be good.
+  // There's really no default way to unwind on s390x. Trust the .eh_frame
+  // CFI, which should always be good.
   return false;
 }
 
 bool ABISysV_s390x::GetFallbackRegisterLocation(
     const RegisterInfo *reg_info,
     UnwindPlan::Row::RegisterLocation &unwind_regloc) {
-  // If a volatile register is being requested, we don't want to forward the
-  // next frame's register contents
-  // up the stack -- the register is not retrievable at this frame.
+  // If a volatile register is being requested, we don't want to forward
+  // the next frame's register contents up the stack -- the register is
+  // not retrievable at this frame.
   if (RegisterIsVolatile(reg_info)) {
     unwind_regloc.SetUndefined();
     return true;
Index: source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp
===================================================================
--- source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp
+++ source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp
@@ -1064,9 +1064,9 @@
 
 const lldb_private::RegisterInfo *
 ABISysV_x86_64::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
+  // Make the C-string names and alt_names for the register infos into
+  // const C-string values by having the ConstString unique the names in
+  // the global constant C-string pool.
   if (!g_register_info_names_constified) {
     g_register_info_names_constified = true;
     for (uint32_t i = 0; i < k_num_register_infos; ++i) {
@@ -1228,8 +1228,8 @@
   if (!reg_ctx)
     return false;
 
-  // Get the pointer to the first stack argument so we have a place to start
-  // when reading data
+  // Get the pointer to the first stack argument so we have a place to
+  // start when reading data
 
   addr_t sp = reg_ctx->GetSP(0);
 
@@ -1370,9 +1370,9 @@
   }
 
   if (!set_it_simple) {
-    // Okay we've got a structure or something that doesn't fit in a simple
-    // register.
-    // We should figure out where it really goes, but we don't support this yet.
+    // Okay we've got a structure or something that doesn't fit in a
+    // simple register. We should figure out where it really goes, but we
+    // don't support this yet.
     error.SetErrorString("We only support setting simple integer and float "
                          "return types at present.");
   }
@@ -1401,7 +1401,8 @@
 
     bool success = false;
     if (type_flags & eTypeIsInteger) {
-      // Extract the register context so we can read arguments from registers
+      // Extract the register context so we can read arguments from
+      // registers
 
       const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
       uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
@@ -1463,8 +1464,8 @@
                 value.GetScalar() = (double)data.GetDouble(&offset);
                 success = true;
               } else if (byte_size == sizeof(long double)) {
-                // Don't handle long double since that can be encoded as 80 bit
-                // floats...
+                // Don't handle long double since that can be encoded as
+                // 80 bit floats...
               }
             }
           }
@@ -1610,7 +1611,8 @@
 
       const uint32_t num_children = return_compiler_type.GetNumFields();
 
-      // Since we are in the small struct regime, assume we are not in memory.
+      // Since we are in the small struct regime, assume we are not in
+      // memory.
       is_memory = false;
 
       for (uint32_t idx = 0; idx < num_children; idx++) {
@@ -1624,8 +1626,8 @@
             idx, name, &field_bit_offset, nullptr, nullptr);
         const size_t field_bit_width = field_compiler_type.GetBitSize(&thread);
 
-        // if we don't know the size of the field (e.g. invalid type), just bail
-        // out
+        // if we don't know the size of the field (e.g. invalid type),
+        // just bail out
         if (field_bit_width == 0)
           break;
 
@@ -1645,7 +1647,8 @@
             field_compiler_type.IsPointerType()) {
           if (integer_bytes < 8) {
             if (integer_bytes + field_byte_width <= 8) {
-              // This is in RAX, copy from register to our result structure:
+              // This is in RAX, copy from register to our result
+              // structure:
               copy_from_extractor = &rax_data;
               copy_from_offset = integer_bytes;
               integer_bytes += field_byte_width;
@@ -1661,10 +1664,9 @@
             copy_from_offset = integer_bytes - 8;
             integer_bytes += field_byte_width;
           } else {
-            // The last field didn't fit.  I can't see how that would happen w/o
-            // the overall size being
-            // greater than 16 bytes.  For now, return a nullptr return value
-            // object.
+            // The last field didn't fit.  I can't see how that would
+            // happen w/o the overall size being greater than 16 bytes.
+            // For now, return a nullptr return value object.
             return return_valobj_sp;
           }
         } else if (field_compiler_type.IsFloatingPointType(count, is_complex)) {
@@ -1682,15 +1684,15 @@
             copy_from_offset = 0;
             fp_bytes += field_byte_width;
           } else if (field_bit_width == 32) {
-            // This one is kind of complicated.  If we are in an "eightbyte"
-            // with another float, we'll
-            // be stuffed into an xmm register with it.  If we are in an
-            // "eightbyte" with one or more ints,
-            // then we will be stuffed into the appropriate GPR with them.
+            // This one is kind of complicated.  If we are in an
+            // "eightbyte" with another float, we'll be stuffed into an
+            // xmm register with it.  If we are in an "eightbyte" with one
+            // or more ints, then we will be stuffed into the appropriate
+            // GPR with them.
             bool in_gpr;
             if (field_byte_offset % 8 == 0) {
-              // We are at the beginning of one of the eightbytes, so check the
-              // next element (if any)
+              // We are at the beginning of one of the eightbytes, so
+              // check the next element (if any)
               if (idx == num_children - 1)
                 in_gpr = false;
               else {
@@ -1708,9 +1710,9 @@
                 }
               }
             } else if (field_byte_offset % 4 == 0) {
-              // We are inside of an eightbyte, so see if the field before us is
-              // floating point:
-              // This could happen if somebody put padding in the structure.
+              // We are inside of an eightbyte, so see if the field before
+              // us is floating point: This could happen if somebody put
+              // padding in the structure.
               if (idx == 0)
                 in_gpr = false;
               else {
@@ -1732,11 +1734,12 @@
               continue;
             }
 
-            // Okay, we've figured out whether we are in GPR or XMM, now figure
-            // out which one.
+            // Okay, we've figured out whether we are in GPR or XMM, now
+            // figure out which one.
             if (in_gpr) {
               if (integer_bytes < 8) {
-                // This is in RAX, copy from register to our result structure:
+                // This is in RAX, copy from register to our result
+                // structure:
                 copy_from_extractor = &rax_data;
                 copy_from_offset = integer_bytes;
                 integer_bytes += field_byte_width;
@@ -1757,8 +1760,8 @@
         }
 
         // These two tests are just sanity checks.  If I somehow get the
-        // type calculation wrong above it is better to just return nothing
-        // than to assert or crash.
+        // type calculation wrong above it is better to just return
+        // nothing than to assert or crash.
         if (!copy_from_extractor)
           return return_valobj_sp;
         if (copy_from_offset + field_byte_width >
@@ -1772,20 +1775,19 @@
       }
 
       if (!is_memory) {
-        // The result is in our data buffer.  Let's make a variable object out
-        // of it:
+        // The result is in our data buffer.  Let's make a variable object
+        // out of it:
         return_valobj_sp = ValueObjectConstResult::Create(
             &thread, return_compiler_type, ConstString(""), return_ext);
       }
     }
 
-    // FIXME: This is just taking a guess, rax may very well no longer hold the
-    // return storage location.
-    // If we are going to do this right, when we make a new frame we should
-    // check to see if it uses a memory
-    // return, and if we are at the first instruction and if so stash away the
-    // return location.  Then we would
-    // only return the memory return value if we know it is valid.
+    // FIXME: This is just taking a guess, rax may very well no longer
+    // hold the return storage location. If we are going to do this right,
+    // when we make a new frame we should check to see if it uses a memory
+    // return, and if we are at the first instruction and if so stash away
+    // the return location.  Then we would only return the memory return
+    // value if we know it is valid.
 
     if (is_memory) {
       unsigned rax_id =
@@ -1858,13 +1860,13 @@
 
 // See "Register Usage" in the
 // "System V Application Binary Interface"
-// "AMD64 Architecture Processor Supplement"
-// (or "x86-64(tm) Architecture Processor Supplement" in earlier revisions)
-// (this doc is also commonly referred to as the x86-64/AMD64 psABI)
-// Edited by Michael Matz, Jan Hubicka, Andreas Jaeger, and Mark Mitchell
-// current version is 0.99.6 released 2012-07-02 at
-// http://refspecs.linuxfoundation.org/elf/x86-64-abi-0.99.pdf
-// It's being revised & updated at https://github.com/hjl-tools/x86-psABI/
+// "AMD64 Architecture Processor Supplement" (or "x86-64(tm) Architecture
+// Processor Supplement" in earlier revisions) (this doc is also commonly
+// referred to as the x86-64/AMD64 psABI) Edited by Michael Matz, Jan
+// Hubicka, Andreas Jaeger, and Mark Mitchell current version is 0.99.6
+// released 2012-07-02 at
+// http://refspecs.linuxfoundation.org/elf/x86-64-abi-0.99.pdf It's being
+// revised & updated at https://github.com/hjl-tools/x86-psABI/
 
 bool ABISysV_x86_64::RegisterIsCalleeSaved(const RegisterInfo *reg_info) {
   if (!reg_info)
Index: source/Plugins/Architecture/Arm/ArchitectureArm.cpp
===================================================================
--- source/Plugins/Architecture/Arm/ArchitectureArm.cpp
+++ source/Plugins/Architecture/Arm/ArchitectureArm.cpp
@@ -43,10 +43,10 @@
 
 void ArchitectureArm::OverrideStopInfo(Thread &thread) {
   // We need to check if we are stopped in Thumb mode in a IT instruction
-  // and detect if the condition doesn't pass. If this is the case it means
-  // we won't actually execute this instruction. If this happens we need to
-  // clear the stop reason to no thread plans think we are stopped for a
-  // reason and the plans should keep going.
+  // and detect if the condition doesn't pass. If this is the case it
+  // means we won't actually execute this instruction. If this happens we
+  // need to clear the stop reason to no thread plans think we are stopped
+  // for a reason and the plans should keep going.
   //
   // We do this because when single stepping many ARM processes, debuggers
   // often use the BVR/BCR registers that says "stop when the PC is not
@@ -54,22 +54,22 @@
   // up stopping on instructions inside an if/then block that wouldn't get
   // executed. By fixing this we can stop the debugger from seeming like
   // you stepped through both the "if" _and_ the "else" clause when source
-  // level stepping because the debugger stops regardless due to the BVR/BCR
-  // triggering a stop.
+  // level stepping because the debugger stops regardless due to the
+  // BVR/BCR triggering a stop.
   //
   // It also means we can set breakpoints on instructions inside an an
   // if/then block and correctly skip them if we use the BKPT instruction.
-  // The ARM and Thumb BKPT instructions are unconditional even when executed
-  // in a Thumb IT block.
+  // The ARM and Thumb BKPT instructions are unconditional even when
+  // executed in a Thumb IT block.
   //
   // If your debugger inserts software traps in ARM/Thumb code, it will
   // need to use 16 and 32 bit instruction for 16 and 32 bit thumb
   // instructions respectively. If your debugger inserts a 16 bit thumb
-  // trap on top of a 32 bit thumb instruction for an opcode that is inside
-  // an if/then, it will change the it/then to conditionally execute your
-  // 16 bit trap and then cause your program to crash if it executes the
-  // trailing 16 bits (the second half of the 32 bit thumb instruction you
-  // partially overwrote).
+  // trap on top of a 32 bit thumb instruction for an opcode that is
+  // inside an if/then, it will change the it/then to conditionally
+  // execute your 16 bit trap and then cause your program to crash if it
+  // executes the trailing 16 bits (the second half of the 32 bit thumb
+  // instruction you partially overwrote).
 
   RegisterContextSP reg_ctx_sp(thread.GetRegisterContext());
   if (!reg_ctx_sp)
@@ -84,33 +84,31 @@
   const uint32_t T = Bit32(cpsr, 5);
   const uint32_t ISETSTATE = J << 1 | T;
   if (ISETSTATE == 0) {
-// NOTE: I am pretty sure we want to enable the code below
-// that detects when we stop on an instruction in ARM mode
-// that is conditional and the condition doesn't pass. This
-// can happen if you set a breakpoint on an instruction that
-// is conditional. We currently will _always_ stop on the
-// instruction which is bad. You can also run into this while
-// single stepping and you could appear to run code in the "if"
-// and in the "else" clause because it would stop at all of the
-// conditional instructions in both.
-// In such cases, we really don't want to stop at this location.
-// I will check with the lldb-dev list first before I enable this.
+// NOTE: I am pretty sure we want to enable the code below that detects
+// when we stop on an instruction in ARM mode that is conditional and the
+// condition doesn't pass. This can happen if you set a breakpoint on an
+// instruction that is conditional. We currently will _always_ stop on the
+// instruction which is bad. You can also run into this while single
+// stepping and you could appear to run code in the "if" and in the "else"
+// clause because it would stop at all of the conditional instructions in
+// both. In such cases, we really don't want to stop at this location. I
+// will check with the lldb-dev list first before I enable this.
 #if 0
     // ARM mode: check for condition on intsruction
     const addr_t pc = reg_ctx_sp->GetPC();
     Status error;
-    // If we fail to read the opcode we will get UINT64_MAX as the
-    // result in "opcode" which we can use to detect if we read a
-    // valid opcode.
+    // If we fail to read the opcode we will get UINT64_MAX as the result
+    // in "opcode" which we can use to detect if we read a valid opcode.
     const uint64_t opcode = thread.GetProcess()->ReadUnsignedIntegerFromMemory(pc, 4, UINT64_MAX, error);
     if (opcode <= UINT32_MAX)
     {
         const uint32_t condition = Bits32((uint32_t)opcode, 31, 28);
         if (!ARMConditionPassed(condition, cpsr))
         {
-            // We ARE stopped on an ARM instruction whose condition doesn't
-            // pass so this instruction won't get executed.
-            // Regardless of why it stopped, we need to clear the stop info
+            // We ARE stopped on an ARM instruction whose condition
+            // doesn't pass so this instruction won't get executed.
+            // Regardless of why it stopped, we need to clear the stop
+            // info
             thread.SetStopInfo (StopInfoSP());
         }
     }
@@ -121,9 +119,10 @@
     if (ITSTATE != 0) {
       const uint32_t condition = Bits32(ITSTATE, 7, 4);
       if (!ARMConditionPassed(condition, cpsr)) {
-        // We ARE stopped in a Thumb IT instruction on an instruction whose
-        // condition doesn't pass so this instruction won't get executed.
-        // Regardless of why it stopped, we need to clear the stop info
+        // We ARE stopped in a Thumb IT instruction on an instruction
+        // whose condition doesn't pass so this instruction won't get
+        // executed. Regardless of why it stopped, we need to clear the
+        // stop info
         thread.SetStopInfo(StopInfoSP());
       }
     }
Index: source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
===================================================================
--- source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
+++ source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
@@ -113,8 +113,8 @@
           llvm::MCInst inst;
           const size_t inst_size =
               mc_disasm_ptr->GetMCInst(opcode_data, opcode_data_len, pc, inst);
-          // Be conservative, if we didn't understand the instruction, say it
-          // might branch...
+          // Be conservative, if we didn't understand the instruction, say
+          // it might branch...
           if (inst_size == 0)
             m_does_branch = eLazyBoolYes;
           else {
@@ -148,8 +148,8 @@
           llvm::MCInst inst;
           const size_t inst_size =
               mc_disasm_ptr->GetMCInst(opcode_data, opcode_data_len, pc, inst);
-          // if we didn't understand the instruction, say it doesn't have a
-          // delay slot...
+          // if we didn't understand the instruction, say it doesn't have
+          // a delay slot...
           if (inst_size == 0)
             m_has_delay_slot = eLazyBoolNo;
           else {
@@ -253,8 +253,8 @@
             m_is_valid = true;
           }
         } else {
-          // The opcode isn't evenly sized, so we need to actually use the llvm
-          // disassembler to parse it and get the size.
+          // The opcode isn't evenly sized, so we need to actually use the
+          // llvm disassembler to parse it and get the size.
           uint8_t *opcode_data =
               const_cast<uint8_t *>(data.PeekData(data_offset, 1));
           const size_t opcode_data_len = data.BytesLeft(data_offset);
@@ -1081,9 +1081,8 @@
   unsigned flavor = ~0U;
   llvm::Triple triple = arch.GetTriple();
 
-  // So far the only supported flavor is "intel" on x86.  The base class will
-  // set this
-  // correctly coming in.
+  // So far the only supported flavor is "intel" on x86.  The base class
+  // will set this correctly coming in.
   if (triple.getArch() == llvm::Triple::x86 ||
       triple.getArch() == llvm::Triple::x86_64) {
     if (m_flavor == "intel") {
@@ -1106,13 +1105,11 @@
     thumb_arch.GetTriple().setArchName(llvm::StringRef(thumb_arch_name));
   }
 
-  // If no sub architecture specified then use the most recent arm architecture
-  // so the
-  // disassembler will return all instruction. Without it we will see a lot of
-  // unknow opcode
-  // in case the code uses instructions which are not available in the oldest
-  // arm version
-  // (used when no sub architecture is specified)
+  // If no sub architecture specified then use the most recent arm
+  // architecture so the disassembler will return all instruction. Without
+  // it we will see a lot of unknow opcode in case the code uses
+  // instructions which are not available in the oldest arm version (used
+  // when no sub architecture is specified)
   if (triple.getArch() == llvm::Triple::arm &&
       triple.getSubArch() == llvm::Triple::NoSubArch)
     triple.setArchName("armv8.2a");
@@ -1186,21 +1183,21 @@
       features_str += "+dspr2,";
   }
 
-  // If any AArch64 variant, enable the ARMv8.2 ISA
-  // extensions so we can disassemble newer instructions.
+  // If any AArch64 variant, enable the ARMv8.2 ISA extensions so we can
+  // disassemble newer instructions.
   if (triple.getArch() == llvm::Triple::aarch64)
     features_str += "+v8.2a";
 
-  // We use m_disasm_ap.get() to tell whether we are valid or not,
-  // so if this isn't good for some reason,
-  // we won't be valid and FindPlugin will fail and we won't get used.
+  // We use m_disasm_ap.get() to tell whether we are valid or not, so if
+  // this isn't good for some reason, we won't be valid and FindPlugin
+  // will fail and we won't get used.
   m_disasm_up = MCDisasmInstance::Create(triple_str, cpu, features_str.c_str(),
                                          flavor, *this);
 
   llvm::Triple::ArchType llvm_arch = triple.getArch();
 
-  // For arm CPUs that can execute arm or thumb instructions, also create a
-  // thumb instruction disassembler.
+  // For arm CPUs that can execute arm or thumb instructions, also create
+  // a thumb instruction disassembler.
   if (llvm_arch == llvm::Triple::arm) {
     std::string thumb_triple(thumb_arch.GetTriple().getTriple());
     m_alternate_disasm_up =
@@ -1393,8 +1390,8 @@
 
         // If the "value" address (the target address we're symbolicating)
         // is inside the same SymbolContext as the current instruction pc
-        // (pc_so_addr), don't print the full function name - just print it
-        // with DumpStyleNoFunctionName style, e.g. "<+36>".
+        // (pc_so_addr), don't print the full function name - just print
+        // it with DumpStyleNoFunctionName style, e.g. "<+36>".
         if (format_omitting_current_func_name) {
           value_so_addr.Dump(&ss, target, Address::DumpStyleNoFunctionName,
                              Address::DumpStyleSectionNameOffset);
@@ -1406,10 +1403,9 @@
         }
 
         if (!ss.GetString().empty()) {
-          // If Address::Dump returned a multi-line description, most commonly
-          // seen when we
-          // have multiple levels of inlined functions at an address, only show
-          // the first line.
+          // If Address::Dump returned a multi-line description, most
+          // commonly seen when we have multiple levels of inlined
+          // functions at an address, only show the first line.
           std::string str = ss.GetString();
           size_t first_eol_char = str.find_first_of("\r\n");
           if (first_eol_char != std::string::npos) {
Index: source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp
===================================================================
--- source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp
+++ source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp
@@ -45,10 +45,10 @@
 using namespace lldb;
 using namespace lldb_private;
 
-// Progressively greater amounts of scanning we will allow
-// For some targets very early in startup, we can't do any random reads of
-// memory or we can crash the device
-// so a setting is needed that can completely disable the KASLR scans.
+// Progressively greater amounts of scanning we will allow For some
+// targets very early in startup, we can't do any random reads of memory
+// or we can crash the device so a setting is needed that can completely
+// disable the KASLR scans.
 
 enum KASLRScanType {
   eKASLRScanNone = 0,        // No reading into the inferior at all
@@ -122,9 +122,9 @@
 }
 
 //----------------------------------------------------------------------
-// Create an instance of this class. This function is filled into
-// the plugin info class that gets handed out by the plugin factory and
-// allows the lldb to instantiate an instance of this class.
+// Create an instance of this class. This function is filled into the
+// plugin info class that gets handed out by the plugin factory and allows
+// the lldb to instantiate an instance of this class.
 //----------------------------------------------------------------------
 DynamicLoader *DynamicLoaderDarwinKernel::CreateInstance(Process *process,
                                                          bool force) {
@@ -141,8 +141,8 @@
       }
     }
 
-    // If the target's architecture does not look like an Apple environment,
-    // this plugin should not create an instance.
+    // If the target's architecture does not look like an Apple
+    // environment, this plugin should not create an instance.
     const llvm::Triple &triple_ref =
         process->GetTarget().GetArchitecture().GetTriple();
     switch (triple_ref.getOS()) {
@@ -155,8 +155,8 @@
         return NULL;
       }
       break;
-    // If we have triple like armv7-unknown-unknown, we should try looking for a
-    // Darwin kernel.
+    // If we have triple like armv7-unknown-unknown, we should try looking
+    // for a Darwin kernel.
     case llvm::Triple::UnknownOS:
       break;
     default:
@@ -166,9 +166,9 @@
   }
 
   // At this point if there is an ExecutableModule, it is a kernel and the
-  // Target is some variant of an Apple system.
-  // If the Process hasn't provided the kernel load address, we need to look
-  // around in memory to find it.
+  // Target is some variant of an Apple system. If the Process hasn't
+  // provided the kernel load address, we need to look around in memory to
+  // find it.
 
   const addr_t kernel_load_address = SearchForDarwinKernel(process);
   if (CheckForKernelImageAtAddress(kernel_load_address, process).IsValid()) {
@@ -197,10 +197,9 @@
 }
 
 //----------------------------------------------------------------------
-// Check if the kernel binary is loaded in memory without a slide.
-// First verify that the ExecutableModule is a kernel before we proceed.
-// Returns the address of the kernel if one was found, else
-// LLDB_INVALID_ADDRESS.
+// Check if the kernel binary is loaded in memory without a slide. First
+// verify that the ExecutableModule is a kernel before we proceed. Returns
+// the address of the kernel if one was found, else LLDB_INVALID_ADDRESS.
 //----------------------------------------------------------------------
 lldb::addr_t
 DynamicLoaderDarwinKernel::SearchForKernelAtSameLoadAddr(Process *process) {
@@ -228,10 +227,9 @@
 }
 
 //----------------------------------------------------------------------
-// If the debug flag is included in the boot-args nvram setting, the kernel's
-// load address
-// will be noted in the lowglo page at a fixed address
-// Returns the address of the kernel if one was found, else
+// If the debug flag is included in the boot-args nvram setting, the
+// kernel's load address will be noted in the lowglo page at a fixed
+// address Returns the address of the kernel if one was found, else
 // LLDB_INVALID_ADDRESS.
 //----------------------------------------------------------------------
 lldb::addr_t
@@ -282,11 +280,11 @@
 }
 
 //----------------------------------------------------------------------
-// If the kernel is currently executing when lldb attaches, and we don't have
-// a better way of finding the kernel's load address, try searching backwards
-// from the current pc value looking for the kernel's Mach header in memory.
-// Returns the address of the kernel if one was found, else
-// LLDB_INVALID_ADDRESS.
+// If the kernel is currently executing when lldb attaches, and we don't
+// have a better way of finding the kernel's load address, try searching
+// backwards from the current pc value looking for the kernel's Mach
+// header in memory. Returns the address of the kernel if one was found,
+// else LLDB_INVALID_ADDRESS.
 //----------------------------------------------------------------------
 lldb::addr_t
 DynamicLoaderDarwinKernel::SearchForKernelNearPC(Process *process) {
@@ -303,17 +301,16 @@
   if (pc == LLDB_INVALID_ADDRESS)
     return LLDB_INVALID_ADDRESS;
 
-  // The kernel will load at at one megabyte boundary (0x100000), or at that
-  // boundary plus
-  // an offset of one page (0x1000) or two, or four (0x4000), depending on the
-  // device.
+  // The kernel will load at at one megabyte boundary (0x100000), or at
+  // that boundary plus an offset of one page (0x1000) or two, or four
+  // (0x4000), depending on the device.
 
-  // Round the current pc down to the nearest one megabyte boundary - the place
-  // where we will start searching.
+  // Round the current pc down to the nearest one megabyte boundary - the
+  // place where we will start searching.
   addr_t addr = pc & ~0xfffff;
 
-  // Search backwards 32 megabytes, looking for the start of the kernel at each
-  // one-megabyte boundary.
+  // Search backwards 32 megabytes, looking for the start of the kernel at
+  // each one-megabyte boundary.
   for (int i = 0; i < 32; i++, addr -= 0x100000) {
     if (CheckForKernelImageAtAddress(addr, process).IsValid())
       return addr;
@@ -329,11 +326,10 @@
 }
 
 //----------------------------------------------------------------------
-// Scan through the valid address range for a kernel binary.
-// This is uselessly slow in 64-bit environments so we don't even try it.
-// This scan is not enabled by default even for 32-bit targets.
-// Returns the address of the kernel if one was found, else
-// LLDB_INVALID_ADDRESS.
+// Scan through the valid address range for a kernel binary. This is
+// uselessly slow in 64-bit environments so we don't even try it. This
+// scan is not enabled by default even for 32-bit targets. Returns the
+// address of the kernel if one was found, else LLDB_INVALID_ADDRESS.
 //----------------------------------------------------------------------
 lldb::addr_t DynamicLoaderDarwinKernel::SearchForKernelViaExhaustiveSearch(
     Process *process) {
@@ -350,10 +346,11 @@
     kernel_range_high = UINT32_MAX;
   }
 
-  // Stepping through memory at one-megabyte resolution looking for a kernel
-  // rarely works (fast enough) with a 64-bit address space -- for now, let's
-  // not even bother.  We may be attaching to something which *isn't* a kernel
-  // and we don't want to spin for minutes on-end looking for a kernel.
+  // Stepping through memory at one-megabyte resolution looking for a
+  // kernel rarely works (fast enough) with a 64-bit address space -- for
+  // now, let's not even bother.  We may be attaching to something which
+  // *isn't* a kernel and we don't want to spin for minutes on-end looking
+  // for a kernel.
   if (process->GetTarget().GetArchitecture().GetAddressByteSize() == 8)
     return LLDB_INVALID_ADDRESS;
 
@@ -374,10 +371,9 @@
 }
 
 //----------------------------------------------------------------------
-// Given an address in memory, look to see if there is a kernel image at that
-// address.
-// Returns a UUID; if a kernel was not found at that address, UUID.IsValid()
-// will be false.
+// Given an address in memory, look to see if there is a kernel image at
+// that address. Returns a UUID; if a kernel was not found at that
+// address, UUID.IsValid() will be false.
 //----------------------------------------------------------------------
 lldb_private::UUID
 DynamicLoaderDarwinKernel::CheckForKernelImageAtAddress(lldb::addr_t addr,
@@ -391,9 +387,9 @@
                 "looking for kernel binary at 0x%" PRIx64,
                 addr);
 
-  // First try a quick test -- read the first 4 bytes and see if there is a
-  // valid Mach-O magic field there
-  // (the first field of the mach_header/mach_header_64 struct).
+  // First try a quick test -- read the first 4 bytes and see if there is
+  // a valid Mach-O magic field there (the first field of the
+  // mach_header/mach_header_64 struct).
 
   Status read_error;
   uint8_t magicbuf[4];
@@ -427,8 +423,8 @@
     header.flags = llvm::ByteSwap_32(header.flags);
   }
 
-  // A kernel is an executable which does not have the dynamic link object flag
-  // set.
+  // A kernel is an executable which does not have the dynamic link object
+  // flag set.
   if (header.filetype == llvm::MachO::MH_EXECUTE &&
       (header.flags & llvm::MachO::MH_DYLDLINK) == 0) {
     // Create a full module to get the UUID
@@ -486,9 +482,9 @@
   Status error;
   PlatformSP platform_sp(
       Platform::Create(PlatformDarwinKernel::GetPluginNameStatic(), error));
-  // Only select the darwin-kernel Platform if we've been asked to load kexts.
-  // It can take some time to scan over all of the kext info.plists and that
-  // shouldn't be done if kext loading is explicitly disabled.
+  // Only select the darwin-kernel Platform if we've been asked to load
+  // kexts. It can take some time to scan over all of the kext info.plists
+  // and that shouldn't be done if kext loading is explicitly disabled.
   if (platform_sp.get() && GetGlobalProperties()->GetLoadKexts()) {
     process->GetTarget().SetPlatform(platform_sp);
   }
@@ -629,11 +625,10 @@
   return m_uuid;
 }
 
-// Given the m_load_address from the kext summaries, and a UUID, try to create
-// an in-memory
-// Module at that address.  Require that the MemoryModule have a matching UUID
-// and detect
-// if this MemoryModule is a kernel or a kext.
+// Given the m_load_address from the kext summaries, and a UUID, try to
+// create an in-memory Module at that address.  Require that the
+// MemoryModule have a matching UUID and detect if this MemoryModule is a
+// kernel or a kext.
 //
 // Returns true if m_memory_module_sp is now set to a valid Module.
 
@@ -667,11 +662,9 @@
     }
   }
 
-  // If this is a kext, and the kernel specified what UUID we should find at
-  // this
-  // load address, require that the memory module have a matching UUID or
-  // something
-  // has gone wrong and we should discard it.
+  // If this is a kext, and the kernel specified what UUID we should find
+  // at this load address, require that the memory module have a matching
+  // UUID or something has gone wrong and we should discard it.
   if (m_uuid.IsValid()) {
     if (m_uuid != memory_module_sp->GetUUID()) {
       if (log) {
@@ -705,9 +698,9 @@
       ModuleSP exe_module_sp = process->GetTarget().GetExecutableModule();
       if (exe_module_sp.get() && exe_module_sp->GetUUID().IsValid()) {
         if (m_uuid != exe_module_sp->GetUUID()) {
-          // The user specified a kernel binary that has a different UUID than
-          // the kernel actually running in memory.  This never ends well;
-          // clear the user specified kernel binary from the Target.
+          // The user specified a kernel binary that has a different UUID
+          // than the kernel actually running in memory.  This never ends
+          // well; clear the user specified kernel binary from the Target.
 
           m_module_sp.reset();
 
@@ -737,9 +730,8 @@
 
   Target &target = process->GetTarget();
 
-  // If we don't have / can't create a memory module for this kext, don't try to
-  // load it - we won't
-  // have the correct segment load addresses.
+  // If we don't have / can't create a memory module for this kext, don't
+  // try to load it - we won't have the correct segment load addresses.
   if (!ReadMemoryModule(process)) {
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
     if (log)
@@ -761,8 +753,8 @@
   }
 
   if (!m_module_sp) {
-    // See if the kext has already been loaded into the target, probably by the
-    // user doing target modules add.
+    // See if the kext has already been loaded into the target, probably
+    // by the user doing target modules add.
     const ModuleList &target_images = target.GetImages();
     m_module_sp = target_images.FindModule(m_uuid);
 
@@ -772,9 +764,8 @@
       module_spec.GetUUID() = m_uuid;
       module_spec.GetArchitecture() = target.GetArchitecture();
 
-      // For the kernel, we really do need an on-disk file copy of the binary to
-      // do anything useful.
-      // This will force a clal to
+      // For the kernel, we really do need an on-disk file copy of the
+      // binary to do anything useful. This will force a clal to
       if (IsKernel()) {
         if (Symbols::DownloadObjectAndSymbolFile(module_spec, true)) {
           if (module_spec.GetFileSpec().Exists()) {
@@ -790,10 +781,9 @@
         }
       }
 
-      // If the current platform is PlatformDarwinKernel, create a ModuleSpec
-      // with the filename set
-      // to be the bundle ID for this kext, e.g.
-      // "com.apple.filesystems.msdosfs", and ask the platform
+      // If the current platform is PlatformDarwinKernel, create a
+      // ModuleSpec with the filename set to be the bundle ID for this
+      // kext, e.g. "com.apple.filesystems.msdosfs", and ask the platform
       // to find it.
       PlatformSP platform_sp(target.GetPlatform());
       if (!m_module_sp && platform_sp) {
@@ -810,11 +800,11 @@
         }
       }
 
-      // Ask the Target to find this file on the local system, if possible.
-      // This will search in the list of currently-loaded files, look in the
-      // standard search paths on the system, and on a Mac it will try calling
-      // the DebugSymbols framework with the UUID to find the binary via its
-      // search methods.
+      // Ask the Target to find this file on the local system, if
+      // possible. This will search in the list of currently-loaded files,
+      // look in the standard search paths on the system, and on a Mac it
+      // will try calling the DebugSymbols framework with the UUID to find
+      // the binary via its search methods.
       if (!m_module_sp) {
         m_module_sp = target.GetSharedModule(module_spec);
       }
@@ -828,8 +818,9 @@
       }
     }
 
-    // If we managed to find a module, append it to the target's list of images.
-    // If we also have a memory module, require that they have matching UUIDs
+    // If we managed to find a module, append it to the target's list of
+    // images. If we also have a memory module, require that they have
+    // matching UUIDs
     if (m_module_sp) {
       bool uuid_match_ok = true;
       if (m_memory_module_sp) {
@@ -863,8 +854,8 @@
       ObjectFile *memory_object_file = m_memory_module_sp->GetObjectFile();
 
       if (memory_object_file && ondisk_object_file) {
-        // The memory_module for kexts may have an invalid __LINKEDIT seg; skip
-        // it.
+        // The memory_module for kexts may have an invalid __LINKEDIT seg;
+        // skip it.
         const bool ignore_linkedit = !IsKernel();
 
         SectionList *ondisk_section_list = ondisk_object_file->GetSectionList();
@@ -872,25 +863,25 @@
         if (memory_section_list && ondisk_section_list) {
           const uint32_t num_ondisk_sections = ondisk_section_list->GetSize();
           // There may be CTF sections in the memory image so we can't
-          // always just compare the number of sections (which are actually
-          // segments in mach-o parlance)
+          // always just compare the number of sections (which are
+          // actually segments in mach-o parlance)
           uint32_t sect_idx = 0;
 
           // Use the memory_module's addresses for each section to set the
-          // file module's load address as appropriate.  We don't want to use
-          // a single slide value for the entire kext - different segments may
-          // be slid different amounts by the kext loader.
+          // file module's load address as appropriate.  We don't want to
+          // use a single slide value for the entire kext - different
+          // segments may be slid different amounts by the kext loader.
 
           uint32_t num_sections_loaded = 0;
           for (sect_idx = 0; sect_idx < num_ondisk_sections; ++sect_idx) {
             SectionSP ondisk_section_sp(
                 ondisk_section_list->GetSectionAtIndex(sect_idx));
             if (ondisk_section_sp) {
-              // Don't ever load __LINKEDIT as it may or may not be actually
-              // mapped into memory and there is no current way to tell.
-              // I filed rdar://problem/12851706 to track being able to tell
-              // if the __LINKEDIT is actually mapped, but until then, we need
-              // to not load the __LINKEDIT
+              // Don't ever load __LINKEDIT as it may or may not be
+              // actually mapped into memory and there is no current way
+              // to tell. I filed rdar://problem/12851706 to track being
+              // able to tell if the __LINKEDIT is actually mapped, but
+              // until then, we need to not load the __LINKEDIT
               if (ignore_linkedit &&
                   ondisk_section_sp->GetName() == g_section_name_LINKEDIT)
                 continue;
@@ -996,9 +987,9 @@
       m_kernel.SetLoadAddress(m_kernel_load_address);
       if (m_kernel.GetLoadAddress() == LLDB_INVALID_ADDRESS &&
           m_kernel.GetModule()) {
-        // We didn't get a hint from the process, so we will
-        // try the kernel at the address that it exists at in
-        // the file if we have one
+        // We didn't get a hint from the process, so we will try the
+        // kernel at the address that it exists at in the file if we have
+        // one
         ObjectFile *kernel_object_file = m_kernel.GetModule()->GetObjectFile();
         if (kernel_object_file) {
           addr_t load_address =
@@ -1009,10 +1000,9 @@
           if (load_address != LLDB_INVALID_ADDRESS && load_address != 0) {
             m_kernel.SetLoadAddress(load_address);
             if (load_address != file_address) {
-              // Don't accidentally relocate the kernel to the File address --
-              // the Load address has already been set to its actual in-memory
-              // address.
-              // Mark it as IsLoaded.
+              // Don't accidentally relocate the kernel to the File
+              // address -- the Load address has already been set to its
+              // actual in-memory address. Mark it as IsLoaded.
               m_kernel.SetProcessStopId(m_process->GetStopID());
             }
           } else {
@@ -1028,10 +1018,11 @@
       }
     }
     
-    // The operating system plugin gets loaded and initialized in 
+    // The operating system plugin gets loaded and initialized in
     // LoadImageUsingMemoryModule when we discover the kernel dSYM.  For a
-    // core file in particular, that's the wrong place to do this, since 
-    // we haven't fixed up the section addresses yet.  So let's redo it here.
+    // core file in particular, that's the wrong place to do this, since
+    // we haven't fixed up the section addresses yet.  So let's redo it
+    // here.
     LoadOperatingSystemPlugin(false);
 
     if (m_kernel.IsLoaded() && m_kernel.GetModule()) {
@@ -1052,9 +1043,9 @@
 
 //----------------------------------------------------------------------
 // Static callback function that gets called when our DYLD notification
-// breakpoint gets hit. We update all of our image infos and then
-// let our super class DynamicLoader class decide if we should stop
-// or not (based on global preference).
+// breakpoint gets hit. We update all of our image infos and then let our
+// super class DynamicLoader class decide if we should stop or not (based
+// on global preference).
 //----------------------------------------------------------------------
 bool DynamicLoaderDarwinKernel::BreakpointHitCallback(
     void *baton, StoppointCallbackContext *context, user_id_t break_id,
@@ -1096,8 +1087,8 @@
     if (m_process->GetTarget().ReadPointerFromMemory(
             m_kext_summary_header_ptr_addr, prefer_file_cache, error,
             m_kext_summary_header_addr)) {
-      // We got a valid address for our kext summary header and make sure it
-      // isn't NULL
+      // We got a valid address for our kext summary header and make sure
+      // it isn't NULL
       if (m_kext_summary_header_addr.IsValid() &&
           m_kext_summary_header_addr.GetFileAddress() != 0) {
         const size_t bytes_read = m_process->GetTarget().ReadMemory(
@@ -1111,8 +1102,8 @@
             s->Printf("WARNING: Unable to read kext summary header, got "
                       "improbable version number %u\n",
                       m_kext_summary_header.version);
-            // If we get an improbably large version number, we're probably
-            // getting bad memory.
+            // If we get an improbably large version number, we're
+            // probably getting bad memory.
             m_kext_summary_header_addr.Clear();
             return false;
           }
@@ -1130,14 +1121,15 @@
               return false;
             }
           } else {
-            // Versions less than 2 didn't have an entry size, it was hard coded
+            // Versions less than 2 didn't have an entry size, it was hard
+            // coded
             m_kext_summary_header.entry_size =
                 KERNEL_MODULE_ENTRY_SIZE_VERSION_1;
           }
           m_kext_summary_header.entry_count = data.GetU32(&offset);
           if (m_kext_summary_header.entry_count > 10000) {
-            // If we get an improbably large number of kexts, we're probably
-            // getting bad memory.
+            // If we get an improbably large number of kexts, we're
+            // probably getting bad memory.
             Stream *s =
                 m_process->GetTarget().GetDebugger().GetOutputFile().get();
             s->Printf("WARNING: Unable to read kext summary header, got "
@@ -1155,14 +1147,11 @@
   return false;
 }
 
-// We've either (a) just attached to a new kernel, or (b) the kexts-changed
-// breakpoint was hit
-// and we need to figure out what kexts have been added or removed.
-// Read the kext summaries from the inferior kernel memory, compare them against
-// the
-// m_known_kexts vector and update the m_known_kexts vector as needed to keep in
-// sync with the
-// inferior.
+// We've either (a) just attached to a new kernel, or (b) the kexts-
+// changed breakpoint was hit and we need to figure out what kexts have
+// been added or removed. Read the kext summaries from the inferior kernel
+// memory, compare them against the m_known_kexts vector and update the
+// m_known_kexts vector as needed to keep in sync with the inferior.
 
 bool DynamicLoaderDarwinKernel::ParseKextSummaries(
     const Address &kext_summary_addr, uint32_t count) {
@@ -1177,15 +1166,14 @@
   if (!ReadKextSummaries(kext_summary_addr, count, kext_summaries))
     return false;
 
-  // read the plugin.dynamic-loader.darwin-kernel.load-kexts setting -- if the
-  // user requested no
-  // kext loading, don't print any messages about kexts & don't try to read
-  // them.
+  // read the plugin.dynamic-loader.darwin-kernel.load-kexts setting -- if
+  // the user requested no kext loading, don't print any messages about
+  // kexts & don't try to read them.
   const bool load_kexts = GetGlobalProperties()->GetLoadKexts();
 
-  // By default, all kexts we've loaded in the past are marked as "remove" and
-  // all of the kexts
-  // we just found out about from ReadKextSummaries are marked as "add".
+  // By default, all kexts we've loaded in the past are marked as "remove"
+  // and all of the kexts we just found out about from ReadKextSummaries
+  // are marked as "add".
   std::vector<bool> to_be_removed(m_known_kexts.size(), true);
   std::vector<bool> to_be_added(count, true);
 
@@ -1195,8 +1183,8 @@
   const uint32_t new_kexts_size = kext_summaries.size();
   const uint32_t old_kexts_size = m_known_kexts.size();
 
-  // The m_known_kexts vector may have entries that have been Cleared,
-  // or are a kernel.
+  // The m_known_kexts vector may have entries that have been Cleared, or
+  // are a kernel.
   for (uint32_t old_kext = 0; old_kext < old_kexts_size; old_kext++) {
     bool ignore = false;
     KextImageInfo &image_info = m_known_kexts[old_kext];
@@ -1213,8 +1201,8 @@
     }
   }
 
-  // Scan over the list of kexts we just read from the kernel, note those that
-  // need to be added and those already loaded.
+  // Scan over the list of kexts we just read from the kernel, note those
+  // that need to be added and those already loaded.
   for (uint32_t new_kext = 0; new_kext < new_kexts_size; new_kext++) {
     bool add_this_one = true;
     for (uint32_t old_kext = 0; old_kext < old_kexts_size; old_kext++) {
@@ -1229,10 +1217,10 @@
         break;
       }
     }
-    // If this "kext" entry is actually an alias for the kernel --
-    // the kext was compiled into the kernel or something -- then
-    // we don't want to load the kernel's text section at a different
-    // address.  Ignore this kext entry.
+    // If this "kext" entry is actually an alias for the kernel -- the
+    // kext was compiled into the kernel or something -- then we don't
+    // want to load the kernel's text section at a different address.
+    // Ignore this kext entry.
     if (kext_summaries[new_kext].GetUUID().IsValid() 
         && m_kernel.GetUUID().IsValid() 
         && kext_summaries[new_kext].GetUUID() == m_kernel.GetUUID()) {
@@ -1321,10 +1309,10 @@
           if (s)
             s->Printf(".");
           image_info.Clear();
-          // should pull it out of the KextImageInfos vector but that would
-          // mutate the list and invalidate
-          // the to_be_removed bool vector; leaving it in place once Cleared()
-          // is relatively harmless.
+          // should pull it out of the KextImageInfos vector but that
+          // would mutate the list and invalidate the to_be_removed bool
+          // vector; leaving it in place once Cleared() is relatively
+          // harmless.
         }
       }
       m_process->GetTarget().ModulesDidUnload(unloaded_module_list, false);
@@ -1433,8 +1421,8 @@
 }
 
 //----------------------------------------------------------------------
-// Dump the _dyld_all_image_infos members and all current image infos
-// that we have parsed to the file handle provided.
+// Dump the _dyld_all_image_infos members and all current image infos that
+// we have parsed to the file handle provided.
 //----------------------------------------------------------------------
 void DynamicLoaderDarwinKernel::PutToLog(Log *log) const {
   if (log == NULL)
Index: source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp
===================================================================
--- source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp
+++ source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp
@@ -157,10 +157,10 @@
   // Callback for the target to give it the loaded module list
   m_process->GetTarget().ModulesDidLoad(module_list);
 
-  // Try to set a breakpoint at the rendezvous breakpoint.
-  // DidLaunch uses ProbeEntry() instead.  That sets a breakpoint,
-  // at the dyld breakpoint address, with a callback so that when hit,
-  // the dyld structure can be parsed.
+  // Try to set a breakpoint at the rendezvous breakpoint. DidLaunch uses
+  // ProbeEntry() instead.  That sets a breakpoint, at the dyld breakpoint
+  // address, with a callback so that when hit, the dyld structure can be
+  // parsed.
   if (!SetRendezvousBreakpoint()) {
     // fail
   }
@@ -187,8 +187,8 @@
                          executable->GetArchitecture());
   ModuleSP module_sp(new Module(module_spec));
 
-  // Check if the executable has changed and set it to the target executable if
-  // they differ.
+  // Check if the executable has changed and set it to the target
+  // executable if they differ.
   if (module_sp.get() && module_sp->GetUUID().IsValid() &&
       executable->GetUUID().IsValid()) {
     // if the executable has changed ??
@@ -268,12 +268,11 @@
 bool DynamicLoaderHexagonDYLD::SetRendezvousBreakpoint() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
 
-  // This is the original code, which want to look in the rendezvous structure
-  // to find the breakpoint address.  Its backwards for us, since we can easily
-  // find the breakpoint address, since it is exported in our executable.
-  // We however know that we cant read the Rendezvous structure until we have
-  // hit
-  // the breakpoint once.
+  // This is the original code, which want to look in the rendezvous
+  // structure to find the breakpoint address.  Its backwards for us,
+  // since we can easily find the breakpoint address, since it is exported
+  // in our executable. We however know that we cant read the Rendezvous
+  // structure until we have hit the breakpoint once.
   const ConstString dyldBpName("_rtld_debug_state");
   addr_t break_addr = findSymbolAddress(m_process, dyldBpName);
 
@@ -326,8 +325,8 @@
   DynamicLoaderHexagonDYLD *dyld_instance = nullptr;
   dyld_instance = static_cast<DynamicLoaderHexagonDYLD *>(baton);
 
-  // if the dyld_instance is still not valid then
-  // try to locate it on the symbol table
+  // if the dyld_instance is still not valid then try to locate it on the
+  // symbol table
   if (!dyld_instance->m_rendezvous.IsValid()) {
     Process *proc = dyld_instance->m_process;
 
@@ -410,7 +409,7 @@
   }
 }
 
-// AD:	This is very different to the Static Loader code.
+// AD:     This is very different to the Static Loader code.
 //		It may be wise to look over this and its relation to stack
 //		unwinding.
 ThreadPlanSP
@@ -480,8 +479,8 @@
     return;
   }
 
-  // The rendezvous class doesn't enumerate the main module, so track
-  // that ourselves here.
+  // The rendezvous class doesn't enumerate the main module, so track that
+  // ourselves here.
   ModuleSP executable = GetTargetExecutable();
   m_loaded_modules[executable] = m_rendezvous.GetLinkMapAddress();
 
@@ -517,13 +516,13 @@
   return 0;
 }
 
-// Here we must try to read the entry point directly from
-// the elf header.  This is possible if the process is not
-// relocatable or dynamically linked.
+// Here we must try to read the entry point directly from the elf header.
+// This is possible if the process is not relocatable or dynamically
+// linked.
 //
-// an alternative is to look at the PC if we can be sure
-// that we have connected when the process is at the entry point.
-// I dont think that is reliable for us.
+// an alternative is to look at the PC if we can be sure that we have
+// connected when the process is at the entry point. I dont think that is
+// reliable for us.
 addr_t DynamicLoaderHexagonDYLD::GetEntryPoint() {
   if (m_entry_point != LLDB_INVALID_ADDRESS)
     return m_entry_point;
@@ -534,7 +533,8 @@
   Module &module = *(m_process->GetTarget().GetExecutableModule().get());
   // Get the object file (elf file) for this module
   lldb_private::ObjectFile &object = *(module.GetObjectFile());
-  // Check if the file is executable (ie, not shared object or relocatable)
+  // Check if the file is executable (ie, not shared object or
+  // relocatable)
   if (object.IsExecutable()) {
     // Get the entry point address for this object
     lldb_private::Address entry = object.GetEntryPointAddress();
Index: source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.cpp
===================================================================
--- source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.cpp
+++ source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.cpp
@@ -116,18 +116,18 @@
     return false;
 
   // When the previous and current states are consistent this is the first
-  // time we have been asked to update.  Just take a snapshot of the currently
-  // loaded modules.
+  // time we have been asked to update.  Just take a snapshot of the
+  // currently loaded modules.
   if (m_previous.state == eConsistent && m_current.state == eConsistent)
     return TakeSnapshot(m_soentries);
 
-  // If we are about to add or remove a shared object clear out the current
-  // state and take a snapshot of the currently loaded images.
+  // If we are about to add or remove a shared object clear out the
+  // current state and take a snapshot of the currently loaded images.
   if (m_current.state == eAdd || m_current.state == eDelete) {
     // this is a fudge so that we can clear the assert below.
     m_previous.state = eConsistent;
-    // We hit this assert on the 2nd run of this function after running the calc
-    // example
+    // We hit this assert on the 2nd run of this function after running
+    // the calc example
     assert(m_previous.state == eConsistent);
     m_soentries.clear();
     m_added_soentries.clear();
@@ -136,8 +136,8 @@
   }
   assert(m_current.state == eConsistent);
 
-  // Otherwise check the previous state to determine what to expect and update
-  // accordingly.
+  // Otherwise check the previous state to determine what to expect and
+  // update accordingly.
   if (m_previous.state == eAdd)
     return UpdateSOEntriesForAddition();
   else if (m_previous.state == eDelete)
@@ -159,9 +159,9 @@
     if (!ReadSOEntryFromMemory(cursor, entry))
       return false;
 
-    // Only add shared libraries and not the executable.
-    // On Linux this is indicated by an empty path in the entry.
-    // On FreeBSD it is the name of the executable.
+    // Only add shared libraries and not the executable. On Linux this is
+    // indicated by an empty path in the entry. On FreeBSD it is the name
+    // of the executable.
     if (entry.path.empty() || ::strcmp(entry.path.c_str(), m_exe_path) == 0)
       continue;
 
@@ -204,9 +204,9 @@
     if (!ReadSOEntryFromMemory(cursor, entry))
       return false;
 
-    // Only add shared libraries and not the executable.
-    // On Linux this is indicated by an empty path in the entry.
-    // On FreeBSD it is the name of the executable.
+    // Only add shared libraries and not the executable. On Linux this is
+    // indicated by an empty path in the entry. On FreeBSD it is the name
+    // of the executable.
     if (entry.path.empty() || ::strcmp(entry.path.c_str(), m_exe_path) == 0)
       continue;
 
Index: source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp
===================================================================
--- source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp
+++ source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp
@@ -112,8 +112,8 @@
 
   if (module_sp && !module_spec.GetUUID().IsValid() &&
       !module_sp->GetUUID().IsValid()) {
-    // No UUID, we must rely upon the cached module modification
-    // time and the modification time of the file on disk
+    // No UUID, we must rely upon the cached module modification time and
+    // the modification time of the file on disk
     if (module_sp->GetModificationTime() !=
         FileSystem::GetModificationTime(module_sp->GetFileSpec()))
       module_sp.reset();
@@ -197,9 +197,8 @@
   for (size_t i = 0; i < num_modules; i++) {
     ModuleSP module_sp = target_modules.GetModuleAtIndexUnlocked(i);
 
-    // Don't remove dyld - else we'll lose our breakpoint notifying us about
-    // libraries
-    // being re-loaded...
+    // Don't remove dyld - else we'll lose our breakpoint notifying us
+    // about libraries being re-loaded...
     if (module_sp.get() != nullptr && module_sp.get() != dyld_sp.get()) {
       UnloadSections(module_sp);
       unloaded_modules_list.Append(module_sp);
@@ -219,8 +218,8 @@
 }
 
 //----------------------------------------------------------------------
-// Update the load addresses for all segments in MODULE using the
-// updated INFO that is passed in.
+// Update the load addresses for all segments in MODULE using the updated
+// INFO that is passed in.
 //----------------------------------------------------------------------
 bool DynamicLoaderDarwin::UpdateImageLoadAddress(Module *module,
                                                  ImageInfo &info) {
@@ -231,13 +230,13 @@
       SectionList *section_list = image_object_file->GetSectionList();
       if (section_list) {
         std::vector<uint32_t> inaccessible_segment_indexes;
-        // We now know the slide amount, so go through all sections
-        // and update the load addresses with the correct values.
+        // We now know the slide amount, so go through all sections and
+        // update the load addresses with the correct values.
         const size_t num_segments = info.segments.size();
         for (size_t i = 0; i < num_segments; ++i) {
           // Only load a segment if it has protections. Things like
-          // __PAGEZERO don't have any protections, and they shouldn't
-          // be slid
+          // __PAGEZERO don't have any protections, and they shouldn't be
+          // slid
           SectionSP section_sp(
               section_list->FindSectionByName(info.segments[i].name));
 
@@ -249,10 +248,10 @@
             static ConstString g_section_name_LINKEDIT("__LINKEDIT");
 
             if (section_sp) {
-              // __LINKEDIT sections from files in the shared cache
-              // can overlap so check to see what the segment name is
-              // and pass "false" so we don't warn of overlapping
-              // "Section" objects, and "true" for all other sections.
+              // __LINKEDIT sections from files in the shared cache can
+              // overlap so check to see what the segment name is and pass
+              // "false" so we don't warn of overlapping "Section"
+              // objects, and "true" for all other sections.
               const bool warn_multiple =
                   section_sp->GetName() != g_section_name_LINKEDIT;
 
@@ -272,11 +271,11 @@
 
         // If the loaded the file (it changed) and we have segments that
         // are not readable or writeable, add them to the invalid memory
-        // region cache for the process. This will typically only be
-        // the __PAGEZERO segment in the main executable. We might be able
-        // to apply this more generally to more sections that have no
-        // protections in the future, but for now we are going to just
-        // do __PAGEZERO.
+        // region cache for the process. This will typically only be the
+        // __PAGEZERO segment in the main executable. We might be able to
+        // apply this more generally to more sections that have no
+        // protections in the future, but for now we are going to just do
+        // __PAGEZERO.
         if (changed && !inaccessible_segment_indexes.empty()) {
           for (uint32_t i = 0; i < inaccessible_segment_indexes.size(); ++i) {
             const uint32_t seg_idx = inaccessible_segment_indexes[i];
@@ -298,7 +297,8 @@
       }
     }
   }
-  // We might have an in memory image that was loaded as soon as it was created
+  // We might have an in memory image that was loaded as soon as it was
+  // created
   if (info.load_stop_id == m_process->GetStopID())
     changed = true;
   else if (changed) {
@@ -343,9 +343,9 @@
   return changed;
 }
 
-// Given a JSON dictionary (from debugserver, most likely) of binary images
-// loaded in the inferior
-// process, add the images to the ImageInfo collection.
+// Given a JSON dictionary (from debugserver, most likely) of binary
+// images loaded in the inferior process, add the images to the ImageInfo
+// collection.
 
 bool DynamicLoaderDarwin::JSONImageInformationIntoImageInfo(
     StructuredData::ObjectSP image_details,
@@ -411,9 +411,8 @@
               ->GetValue();
     }
 
-    // Fields that aren't used by DynamicLoaderDarwin so debugserver doesn't
-    // currently send them
-    // in the reply.
+    // Fields that aren't used by DynamicLoaderDarwin so debugserver
+    // doesn't currently send them in the reply.
 
     if (mh->HasKey("flags"))
       image_infos[i].header.flags =
@@ -453,9 +452,8 @@
       segment.maxprot =
           seg->GetValueForKey("maxprot")->GetAsInteger()->GetValue();
 
-      // Fields that aren't used by DynamicLoaderDarwin so debugserver doesn't
-      // currently send them
-      // in the reply.
+      // Fields that aren't used by DynamicLoaderDarwin so debugserver
+      // doesn't currently send them in the reply.
 
       if (seg->HasKey("initprot"))
         segment.initprot =
@@ -483,23 +481,22 @@
 
     // All sections listed in the dyld image info structure will all
     // either be fixed up already, or they will all be off by a single
-    // slide amount that is determined by finding the first segment
-    // that is at file offset zero which also has bytes (a file size
-    // that is greater than zero) in the object file.
+    // slide amount that is determined by finding the first segment that
+    // is at file offset zero which also has bytes (a file size that is
+    // greater than zero) in the object file.
 
     // Determine the slide amount (if any)
     const size_t num_sections = image_infos[i].segments.size();
     for (size_t k = 0; k < num_sections; ++k) {
-      // Iterate through the object file sections to find the
-      // first section that starts of file offset zero and that
-      // has bytes in the file...
+      // Iterate through the object file sections to find the first
+      // section that starts of file offset zero and that has bytes in the
+      // file...
       if ((image_infos[i].segments[k].fileoff == 0 &&
            image_infos[i].segments[k].filesize > 0) ||
           (image_infos[i].segments[k].name == ConstString("__TEXT"))) {
         image_infos[i].slide =
             image_infos[i].address - image_infos[i].segments[k].vmaddr;
-        // We have found the slide amount, so we can exit
-        // this for loop.
+        // We have found the slide amount, so we can exit this for loop.
         break;
       }
     }
@@ -520,12 +517,12 @@
   const size_t image_infos_size = image_infos.size();
   for (size_t i = 0; i < image_infos_size; i++) {
     if (image_infos[i].header.filetype == llvm::MachO::MH_DYLINKER) {
-      // In a "simulator" process (an x86 process that is ios/tvos/watchos)
-      // we will have two dyld modules -- a "dyld" that we want to keep track
-      // of,
-      // and a "dyld_sim" which we don't need to keep track of here.
-      // If the target is an x86 system and the OS of the dyld binary is
-      // ios/tvos/watchos, then we are looking at dyld_sym.
+      // In a "simulator" process (an x86 process that is
+      // ios/tvos/watchos) we will have two dyld modules -- a "dyld" that
+      // we want to keep track of, and a "dyld_sim" which we don't need to
+      // keep track of here. If the target is an x86 system and the OS of
+      // the dyld binary is ios/tvos/watchos, then we are looking at
+      // dyld_sym.
 
       // debugserver has only recently (late 2016) started sending up the
       // os type for each binary it sees -- so if we don't have an os
@@ -543,7 +540,8 @@
         }
       }
       else {
-        // catch-all for any other environment -- trust that dyld is actually dyld
+        // catch-all for any other environment -- trust that dyld is
+        // actually dyld
         dyld_idx = i;
       }
     } else if (image_infos[i].header.filetype == llvm::MachO::MH_EXECUTE) {
@@ -651,10 +649,10 @@
                   commpage_image_module_sp->GetObjectFile() == NULL) {
                 commpage_image_module_sp = m_process->ReadModuleFromMemory(
                     image_infos[idx].file_spec, image_infos[idx].address);
-                // Always load a memory image right away in the target in case
-                // we end up trying to read the symbol table from memory... The
-                // __LINKEDIT will need to be mapped so we can figure out where
-                // the symbol table bits are...
+                // Always load a memory image right away in the target in
+                // case we end up trying to read the symbol table from
+                // memory... The __LINKEDIT will need to be mapped so we
+                // can figure out where the symbol table bits are...
                 bool changed = false;
                 UpdateImageLoadAddress(commpage_image_module_sp.get(),
                                        image_infos[idx]);
@@ -669,11 +667,11 @@
         }
       }
 
-      // UpdateImageLoadAddress will return true if any segments
-      // change load address. We need to check this so we don't
-      // mention that all loaded shared libraries are newly loaded
-      // each time we hit out dyld breakpoint since dyld will list all
-      // shared libraries each time.
+      // UpdateImageLoadAddress will return true if any segments change
+      // load address. We need to check this so we don't mention that all
+      // loaded shared libraries are newly loaded each time we hit out
+      // dyld breakpoint since dyld will list all shared libraries each
+      // time.
       if (UpdateImageLoadAddress(image_module_sp.get(), image_infos[idx])) {
         target_images.AppendIfNeeded(image_module_sp);
         loaded_module_list.AppendIfNeeded(image_module_sp);
@@ -691,18 +689,19 @@
 }
 
 //----------------------------------------------------------------------
-// On Mac OS X libobjc (the Objective-C runtime) has several critical dispatch
-// functions written in hand-written assembly, and also have hand-written unwind
-// information in the eh_frame section.  Normally we prefer analyzing the
-// assembly instructions of a currently executing frame to unwind from that
-// frame --
-// but on hand-written functions this profiling can fail.  We should use the
-// eh_frame instructions for these functions all the time.
+// On Mac OS X libobjc (the Objective-C runtime) has several critical
+// dispatch functions written in hand-written assembly, and also have
+// hand-written unwind information in the eh_frame section.  Normally we
+// prefer analyzing the assembly instructions of a currently executing
+// frame to unwind from that frame -- but on hand-written functions this
+// profiling can fail.  We should use the eh_frame instructions for these
+// functions all the time.
 //
-// As an aside, it would be better if the eh_frame entries had a flag (or were
-// extensible so they could have an Apple-specific flag) which indicates that
-// the instructions are asynchronous -- accurate at every instruction, instead
-// of our normal default assumption that they are not.
+// As an aside, it would be better if the eh_frame entries had a flag (or
+// were extensible so they could have an Apple-specific flag) which
+// indicates that the instructions are asynchronous -- accurate at every
+// instruction, instead of our normal default assumption that they are
+// not.
 //----------------------------------------------------------------------
 
 bool DynamicLoaderDarwin::AlwaysRelyOnEHUnwindInfo(SymbolContext &sym_ctx) {
@@ -935,8 +934,8 @@
         }
       }
     } else if (current_symbol->GetType() == eSymbolTypeReExported) {
-      // I am not sure we could ever end up stopped AT a re-exported symbol.
-      // But just in case:
+      // I am not sure we could ever end up stopped AT a re-exported
+      // symbol. But just in case:
 
       const Symbol *actual_symbol =
           current_symbol->ResolveReExportedSymbol(*(target_sp.get()));
@@ -956,8 +955,8 @@
     }
 
     if (addresses.size() > 0) {
-      // First check whether any of the addresses point to Indirect symbols, and
-      // if they do, resolve them:
+      // First check whether any of the addresses point to Indirect
+      // symbols, and if they do, resolve them:
       std::vector<lldb::addr_t> load_addrs;
       for (Address address : addresses) {
         Symbol *symbol = address.CalculateSymbolContextSymbol();
Index: source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp
===================================================================
--- source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp
+++ source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp
@@ -29,9 +29,9 @@
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
-// Create an instance of this class. This function is filled into
-// the plugin info class that gets handed out by the plugin factory and
-// allows the lldb to instantiate an instance of this class.
+// Create an instance of this class. This function is filled into the
+// plugin info class that gets handed out by the plugin factory and allows
+// the lldb to instantiate an instance of this class.
 //----------------------------------------------------------------------
 DynamicLoader *DynamicLoaderMacOS::CreateInstance(Process *process,
                                                   bool force) {
@@ -144,17 +144,18 @@
 }
 
 //----------------------------------------------------------------------
-// Try and figure out where dyld is by first asking the Process
-// if it knows (which currently calls down in the lldb::Process
-// to get the DYLD info (available on SnowLeopard only). If that fails,
-// then check in the default addresses.
+// Try and figure out where dyld is by first asking the Process if it
+// knows (which currently calls down in the lldb::Process to get the DYLD
+// info (available on SnowLeopard only). If that fails, then check in the
+// default addresses.
 //----------------------------------------------------------------------
 void DynamicLoaderMacOS::DoInitialImageFetch() {
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
 
-  // Remove any binaries we pre-loaded in the Target before launching/attaching.
-  // If the same binaries are present in the process, we'll get them from the
-  // shared module cache, we won't need to re-load them from disk.
+  // Remove any binaries we pre-loaded in the Target before
+  // launching/attaching. If the same binaries are present in the process,
+  // we'll get them from the shared module cache, we won't need to re-load
+  // them from disk.
   UnloadAllImages();
 
   StructuredData::ObjectSP all_image_info_json_sp(
@@ -184,20 +185,19 @@
 
 //----------------------------------------------------------------------
 // Static callback function that gets called when our DYLD notification
-// breakpoint gets hit. We update all of our image infos and then
-// let our super class DynamicLoader class decide if we should stop
-// or not (based on global preference).
+// breakpoint gets hit. We update all of our image infos and then let our
+// super class DynamicLoader class decide if we should stop or not (based
+// on global preference).
 //----------------------------------------------------------------------
 bool DynamicLoaderMacOS::NotifyBreakpointHit(void *baton,
                                              StoppointCallbackContext *context,
                                              lldb::user_id_t break_id,
                                              lldb::user_id_t break_loc_id) {
-  // Let the event know that the images have changed
-  // DYLD passes three arguments to the notification breakpoint.
-  // Arg1: enum dyld_notify_mode mode - 0 = adding, 1 = removing, 2 = remove all
-  // Arg2: unsigned long icount        - Number of shared libraries
-  // added/removed
-  // Arg3: uint64_t mach_headers[]     - Array of load addresses of binaries
+  // Let the event know that the images have changed DYLD passes three
+  // arguments to the notification breakpoint. Arg1: enum dyld_notify_mode
+  // mode - 0 = adding, 1 = removing, 2 = remove all Arg2: unsigned long
+  // icount        - Number of shared libraries added/removed Arg3:
+  // uint64_t mach_headers[]     - Array of load addresses of binaries
   // added/removed
 
   DynamicLoaderMacOS *dyld_instance = (DynamicLoaderMacOS *)baton;
@@ -217,15 +217,16 @@
 
   const lldb::ABISP &abi = process->GetABI();
   if (abi) {
-    // Build up the value array to store the three arguments given above, then
-    // get the values from the ABI:
+    // Build up the value array to store the three arguments given above,
+    // then get the values from the ABI:
 
     ClangASTContext *clang_ast_context =
         process->GetTarget().GetScratchClangASTContext();
     ValueList argument_values;
 
     Value mode_value;    // enum dyld_notify_mode { dyld_notify_adding=0,
-                         // dyld_notify_removing=1, dyld_notify_remove_all=2 };
+                         // dyld_notify_removing=1,
+                         // dyld_notify_remove_all=2 };
     Value count_value;   // unsigned long count
     Value headers_value; // uint64_t machHeaders[] (aka void*)
 
@@ -260,8 +261,8 @@
       uint32_t dyld_mode =
           argument_values.GetValueAtIndex(0)->GetScalar().UInt(-1);
       if (dyld_mode != static_cast<uint32_t>(-1)) {
-        // Okay the mode was right, now get the number of elements, and the
-        // array of new elements...
+        // Okay the mode was right, now get the number of elements, and
+        // the array of new elements...
         uint32_t image_infos_count =
             argument_values.GetValueAtIndex(1)->GetScalar().UInt(-1);
         if (image_infos_count != static_cast<uint32_t>(-1)) {
@@ -328,8 +329,8 @@
   }
 }
 
-// Dump the _dyld_all_image_infos members and all current image infos
-// that we have parsed to the file handle provided.
+// Dump the _dyld_all_image_infos members and all current image infos that
+// we have parsed to the file handle provided.
 //----------------------------------------------------------------------
 void DynamicLoaderMacOS::PutToLog(Log *log) const {
   if (log == NULL)
@@ -406,7 +407,8 @@
   const size_t num_modules = target_modules.GetSize();
   ConstString g_libdyld_name("libdyld.dylib");
 
-  // Find any modules named "libdyld.dylib" and look for the symbol there first
+  // Find any modules named "libdyld.dylib" and look for the symbol there
+  // first
   for (size_t i = 0; i < num_modules; i++) {
     Module *module_pointer = target_modules.GetModulePointerAtIndexUnlocked(i);
     if (module_pointer) {
@@ -432,9 +434,9 @@
     }
   }
 
-  // Default assumption is that it is OK to load images.
-  // Only say that we cannot load images if we find the symbol in libdyld and it
-  // indicates that we cannot.
+  // Default assumption is that it is OK to load images. Only say that we
+  // cannot load images if we find the symbol in libdyld and it indicates
+  // that we cannot.
 
   if (symbol_address != LLDB_INVALID_ADDRESS) {
     {
@@ -445,11 +447,11 @@
       }
     }
   } else {
-    // If we were unable to find _dyld_global_lock_held in any modules, or it is
-    // not loaded into memory yet, we may be at process startup (sitting 
-    // at _dyld_start) - so we should not allow dlopen calls.
-    // But if we found more than one module then we are clearly past _dyld_start
-    // so in that case we'll default to "it's safe".
+    // If we were unable to find _dyld_global_lock_held in any modules, or
+    // it is not loaded into memory yet, we may be at process startup
+    // (sitting  at _dyld_start) - so we should not allow dlopen calls.
+    // But if we found more than one module then we are clearly past
+    // _dyld_start so in that case we'll default to "it's safe".
     if (num_modules <= 1)
         error.SetErrorString("could not find the dyld library or "
                                        "the dyld lock symbol");
@@ -472,7 +474,9 @@
       info_dict = info->GetAsDictionary();
     }
 
-    // {"shared_cache_base_address":140735683125248,"shared_cache_uuid":"DDB8D70C-C9A2-3561-B2C8-BE48A4F33F96","no_shared_cache":false,"shared_cache_private_cache":false}
+    // {"shared_cache_base_address":140735683125248,"shared_cache_uuid
+    // ":"DDB8D70C-
+    // C9A2-3561-B2C8-BE48A4F33F96","no_shared_cache":false,"shared_cache_private_cache":false}
 
     if (info_dict && info_dict->HasKey("shared_cache_uuid") &&
         info_dict->HasKey("no_shared_cache") &&
Index: source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp
===================================================================
--- source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp
+++ source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp
@@ -49,9 +49,9 @@
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
-// Create an instance of this class. This function is filled into
-// the plugin info class that gets handed out by the plugin factory and
-// allows the lldb to instantiate an instance of this class.
+// Create an instance of this class. This function is filled into the
+// plugin info class that gets handed out by the plugin factory and allows
+// the lldb to instantiate an instance of this class.
 //----------------------------------------------------------------------
 DynamicLoader *DynamicLoaderMacOSXDYLD::CreateInstance(Process *process,
                                                        bool force) {
@@ -117,14 +117,15 @@
   if (m_process) {
     // If we are stopped after an exec, we will have only one thread...
     if (m_process->GetThreadList().GetSize() == 1) {
-      // We know if a process has exec'ed if our "m_dyld_all_image_infos_addr"
-      // value differs from the Process' image info address. When a process
-      // execs itself it might cause a change if ASLR is enabled.
+      // We know if a process has exec'ed if our
+      // "m_dyld_all_image_infos_addr" value differs from the Process'
+      // image info address. When a process execs itself it might cause a
+      // change if ASLR is enabled.
       const addr_t shlib_addr = m_process->GetImageInfoAddress();
       if (m_process_image_addr_is_all_images_infos == true &&
           shlib_addr != m_dyld_all_image_infos_addr) {
-        // The image info address from the process is the 'dyld_all_image_infos'
-        // address and it has changed.
+        // The image info address from the process is the
+        // 'dyld_all_image_infos' address and it has changed.
         did_exec = true;
       } else if (m_process_image_addr_is_all_images_infos == false &&
                  shlib_addr == m_dyld.address) {
@@ -133,7 +134,8 @@
         did_exec = true;
       } else {
         // ASLR might be disabled and dyld could have ended up in the same
-        // location. We should try and detect if we are stopped at '_dyld_start'
+        // location. We should try and detect if we are stopped at
+        // '_dyld_start'
         ThreadSP thread_sp(m_process->GetThreadList().GetThreadAtIndex(0));
         if (thread_sp) {
           lldb::StackFrameSP frame_sp(thread_sp->GetStackFrameAtIndex(0));
@@ -185,16 +187,15 @@
 }
 
 //----------------------------------------------------------------------
-// Try and figure out where dyld is by first asking the Process
-// if it knows (which currently calls down in the lldb::Process
-// to get the DYLD info (available on SnowLeopard only). If that fails,
-// then check in the default addresses.
+// Try and figure out where dyld is by first asking the Process if it
+// knows (which currently calls down in the lldb::Process to get the DYLD
+// info (available on SnowLeopard only). If that fails, then check in the
+// default addresses.
 //----------------------------------------------------------------------
 void DynamicLoaderMacOSXDYLD::DoInitialImageFetch() {
   if (m_dyld_all_image_infos_addr == LLDB_INVALID_ADDRESS) {
-    // Check the image info addr as it might point to the
-    // mach header for dyld, or it might point to the
-    // dyld_all_image_infos struct
+    // Check the image info addr as it might point to the mach header for
+    // dyld, or it might point to the dyld_all_image_infos struct
     const addr_t shlib_addr = m_process->GetImageInfoAddress();
     if (shlib_addr != LLDB_INVALID_ADDRESS) {
       ByteOrder byte_order =
@@ -295,8 +296,8 @@
       if (dyld_module_sp) {
         target.GetImages().AppendIfNeeded(dyld_module_sp);
 
-        // At this point we should have read in dyld's module, and so we should
-        // set breakpoints in it:
+        // At this point we should have read in dyld's module, and so we
+        // should set breakpoints in it:
         ModuleList modules;
         modules.Append(dyld_module_sp);
         target.ModulesDidLoad(modules);
@@ -315,18 +316,18 @@
 
 //----------------------------------------------------------------------
 // Static callback function that gets called when our DYLD notification
-// breakpoint gets hit. We update all of our image infos and then
-// let our super class DynamicLoader class decide if we should stop
-// or not (based on global preference).
+// breakpoint gets hit. We update all of our image infos and then let our
+// super class DynamicLoader class decide if we should stop or not (based
+// on global preference).
 //----------------------------------------------------------------------
 bool DynamicLoaderMacOSXDYLD::NotifyBreakpointHit(
     void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id,
     lldb::user_id_t break_loc_id) {
-  // Let the event know that the images have changed
-  // DYLD passes three arguments to the notification breakpoint.
-  // Arg1: enum dyld_image_mode mode - 0 = adding, 1 = removing
-  // Arg2: uint32_t infoCount        - Number of shared libraries added
-  // Arg3: dyld_image_info info[]    - Array of structs of the form:
+  // Let the event know that the images have changed DYLD passes three
+  // arguments to the notification breakpoint. Arg1: enum dyld_image_mode
+  // mode - 0 = adding, 1 = removing Arg2: uint32_t infoCount        -
+  // Number of shared libraries added Arg3: dyld_image_info info[]    -
+  // Array of structs of the form:
   //                                     const struct mach_header
   //                                     *imageLoadAddress
   //                                     const char               *imageFilePath
@@ -334,12 +335,11 @@
 
   DynamicLoaderMacOSXDYLD *dyld_instance = (DynamicLoaderMacOSXDYLD *)baton;
 
-  // First step is to see if we've already initialized the all image infos.  If
-  // we haven't then this function
-  // will do so and return true.  In the course of initializing the
-  // all_image_infos it will read the complete
-  // current state, so we don't need to figure out what has changed from the
-  // data passed in to us.
+  // First step is to see if we've already initialized the all image
+  // infos.  If we haven't then this function will do so and return true.
+  // In the course of initializing the all_image_infos it will read the
+  // complete current state, so we don't need to figure out what has
+  // changed from the data passed in to us.
 
   ExecutionContext exe_ctx(context->exe_ctx_ref);
   Process *process = exe_ctx.GetProcessPtr();
@@ -354,8 +354,8 @@
 
   const lldb::ABISP &abi = process->GetABI();
   if (abi) {
-    // Build up the value array to store the three arguments given above, then
-    // get the values from the ABI:
+    // Build up the value array to store the three arguments given above,
+    // then get the values from the ABI:
 
     ClangASTContext *clang_ast_context =
         process->GetTarget().GetScratchClangASTContext();
@@ -382,17 +382,16 @@
       uint32_t dyld_mode =
           argument_values.GetValueAtIndex(0)->GetScalar().UInt(-1);
       if (dyld_mode != static_cast<uint32_t>(-1)) {
-        // Okay the mode was right, now get the number of elements, and the
-        // array of new elements...
+        // Okay the mode was right, now get the number of elements, and
+        // the array of new elements...
         uint32_t image_infos_count =
             argument_values.GetValueAtIndex(1)->GetScalar().UInt(-1);
         if (image_infos_count != static_cast<uint32_t>(-1)) {
-          // Got the number added, now go through the array of added elements,
-          // putting out the mach header
-          // address, and adding the image.
-          // Note, I'm not putting in logging here, since the AddModules &
-          // RemoveModules functions do
-          // all the logging internally.
+          // Got the number added, now go through the array of added
+          // elements, putting out the mach header address, and adding the
+          // image. Note, I'm not putting in logging here, since the
+          // AddModules & RemoveModules functions do all the logging
+          // internally.
 
           lldb::addr_t image_infos_addr =
               argument_values.GetValueAtIndex(2)->GetScalar().ULongLong();
@@ -468,11 +467,11 @@
         4) {
       m_dyld_all_image_infos.version = data.GetU32(&offset);
       // If anything in the high byte is set, we probably got the byte
-      // order incorrect (the process might not have it set correctly
-      // yet due to attaching to a program without a specified file).
+      // order incorrect (the process might not have it set correctly yet
+      // due to attaching to a program without a specified file).
       if (m_dyld_all_image_infos.version & 0xff000000) {
-        // We have guessed the wrong byte order. Swap it and try
-        // reading the version again.
+        // We have guessed the wrong byte order. Swap it and try reading
+        // the version again.
         if (byte_order == eByteOrderLittle)
           byte_order = eByteOrderBig;
         else
@@ -508,21 +507,18 @@
         uint64_t dyld_all_image_infos_addr = data.GetPointer(&offset);
 
         // When we started, we were given the actual address of the
-        // all_image_infos
-        // struct (probably via TASK_DYLD_INFO) in memory - this address is
-        // stored in
-        // m_dyld_all_image_infos_addr and is the most accurate address we have.
-
-        // We read the dyld_all_image_infos struct from memory; it contains its
-        // own address.
-        // If the address in the struct does not match the actual address,
-        // the dyld we're looking at has been loaded at a different location
-        // (slid) from
-        // where it intended to load.  The addresses in the dyld_all_image_infos
-        // struct
-        // are the original, non-slid addresses, and need to be adjusted.  Most
-        // importantly
-        // the address of dyld and the notification address need to be adjusted.
+        // all_image_infos struct (probably via TASK_DYLD_INFO) in memory
+        // - this address is stored in m_dyld_all_image_infos_addr and is
+        // the most accurate address we have.
+
+        // We read the dyld_all_image_infos struct from memory; it
+        // contains its own address. If the address in the struct does not
+        // match the actual address, the dyld we're looking at has been
+        // loaded at a different location (slid) from where it intended to
+        // load.  The addresses in the dyld_all_image_infos struct are the
+        // original, non-slid addresses, and need to be adjusted.  Most
+        // importantly the address of dyld and the notification address
+        // need to be adjusted.
 
         if (dyld_all_image_infos_addr != m_dyld_all_image_infos_addr) {
           uint64_t image_infos_offset =
@@ -596,8 +592,8 @@
   if (m_process->GetStopID() == m_dyld_image_infos_stop_id)
     return true;
 
-  // First read in the image_infos for the removed modules, and their headers &
-  // load commands.
+  // First read in the image_infos for the removed modules, and their
+  // headers & load commands.
   if (!ReadImageInfos(image_infos_addr, image_infos_count, image_infos)) {
     if (log)
       log->PutCString("Failed reading image infos array.");
@@ -615,29 +611,28 @@
       image_infos[idx].PutToLog(log);
     }
 
-    // Remove this image_infos from the m_all_image_infos.  We do the comparison
-    // by address
-    // rather than by file spec because we can have many modules with the same
-    // "file spec" in the
-    // case that they are modules loaded from memory.
+    // Remove this image_infos from the m_all_image_infos.  We do the
+    // comparison by address rather than by file spec because we can have
+    // many modules with the same "file spec" in the case that they are
+    // modules loaded from memory.
     //
-    // Also copy over the uuid from the old entry to the removed entry so we can
-    // use it to lookup the module in the module list.
+    // Also copy over the uuid from the old entry to the removed entry so
+    // we can use it to lookup the module in the module list.
 
     ImageInfo::collection::iterator pos, end = m_dyld_image_infos.end();
     for (pos = m_dyld_image_infos.begin(); pos != end; pos++) {
       if (image_infos[idx].address == (*pos).address) {
         image_infos[idx].uuid = (*pos).uuid;
 
-        // Add the module from this image_info to the "unloaded_module_list".
-        // We'll remove them all at
-        // one go later on.
+        // Add the module from this image_info to the
+        // "unloaded_module_list". We'll remove them all at one go later
+        // on.
 
         ModuleSP unload_image_module_sp(
             FindTargetModuleForImageInfo(image_infos[idx], false, NULL));
         if (unload_image_module_sp.get()) {
-          // When we unload, be sure to use the image info from the old list,
-          // since that has sections correctly filled in.
+          // When we unload, be sure to use the image info from the old
+          // list, since that has sections correctly filled in.
           UnloadModuleSections(unload_image_module_sp.get(), *pos);
           unloaded_module_list.AppendIfNeeded(unload_image_module_sp);
         } else {
@@ -714,10 +709,10 @@
 
 //----------------------------------------------------------------------
 // If we have found where the "_dyld_all_image_infos" lives in memory,
-// read the current info from it, and then update all image load
-// addresses (or lack thereof).  Only do this if this is the first time
-// we're reading the dyld infos.  Return true if we actually read anything,
-// and false otherwise.
+// read the current info from it, and then update all image load addresses
+// (or lack thereof).  Only do this if this is the first time we're
+// reading the dyld infos.  Return true if we actually read anything, and
+// false otherwise.
 //----------------------------------------------------------------------
 bool DynamicLoaderMacOSXDYLD::InitializeFromAllImageInfos() {
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
@@ -734,9 +729,9 @@
       return true;
 
     if (m_dyld_all_image_infos.dylib_info_addr == 0) {
-      // DYLD is updating the images now.  So we should say we have no images,
-      // and then we'll
-      // figure it out when we hit the added breakpoint.
+      // DYLD is updating the images now.  So we should say we have no
+      // images, and then we'll figure it out when we hit the added
+      // breakpoint.
       return false;
     } else {
       if (!AddModulesUsingImageInfosAddress(
@@ -747,15 +742,13 @@
       }
     }
 
-    // Now we have one more bit of business.  If there is a library left in the
-    // images for our target that
-    // doesn't have a load address, then it must be something that we were
-    // expecting to load (for instance we
-    // read a load command for it) but it didn't in fact load - probably because
-    // DYLD_*_PATH pointed
-    // to an equivalent version.  We don't want it to stay in the target's
-    // module list or it will confuse
-    // us, so unload it here.
+    // Now we have one more bit of business.  If there is a library left
+    // in the images for our target that doesn't have a load address, then
+    // it must be something that we were expecting to load (for instance
+    // we read a load command for it) but it didn't in fact load -
+    // probably because DYLD_*_PATH pointed to an equivalent version.  We
+    // don't want it to stay in the target's module list or it will
+    // confuse us, so unload it here.
     Target &target = m_process->GetTarget();
     const ModuleList &target_modules = target.GetImages();
     ModuleList not_loaded_modules;
@@ -800,8 +793,8 @@
     lldb::offset_t offset = 0;
     ::memset(header, 0, sizeof(llvm::MachO::mach_header));
 
-    // Get the magic byte unswapped so we can figure out what we are dealing
-    // with
+    // Get the magic byte unswapped so we can figure out what we are
+    // dealing with
     DataExtractor data(header_bytes.GetBytes(), header_bytes.GetByteSize(),
                        endian::InlHostByteOrder(), 4);
     header->magic = data.GetU32(&offset);
@@ -840,8 +833,8 @@
                                 load_cmd_data_sp->GetByteSize(), error);
 
       if (load_cmd_bytes_read == header->sizeofcmds) {
-        // Set the load command data and also set the correct endian
-        // swap settings and the correct address size
+        // Set the load command data and also set the correct endian swap
+        // settings and the correct address size
         load_command_data->SetData(load_cmd_data_sp, 0, header->sizeofcmds);
         load_command_data->SetByteOrder(data.GetByteOrder());
         load_command_data->SetAddressByteSize(data.GetAddressByteSize());
@@ -867,8 +860,8 @@
   dylib_info.Clear(true);
 
   for (cmd_idx = 0; cmd_idx < dylib_info.header.ncmds; cmd_idx++) {
-    // Clear out any load command specific data from DYLIB_INFO since
-    // we are about to read it.
+    // Clear out any load command specific data from DYLIB_INFO since we
+    // are about to read it.
 
     if (data.ValidOffsetForDataOfSize(offset,
                                       sizeof(llvm::MachO::load_command))) {
@@ -880,8 +873,8 @@
       case llvm::MachO::LC_SEGMENT: {
         segment.name.SetTrimmedCStringWithLength(
             (const char *)data.GetData(&offset, 16), 16);
-        // We are putting 4 uint32_t values 4 uint64_t values so
-        // we have to use multiple 32 bit gets below.
+        // We are putting 4 uint32_t values 4 uint64_t values so we have
+        // to use multiple 32 bit gets below.
         segment.vmaddr = data.GetU32(&offset);
         segment.vmsize = data.GetU32(&offset);
         segment.fileoff = data.GetU32(&offset);
@@ -922,24 +915,22 @@
     }
   }
 
-  // All sections listed in the dyld image info structure will all
-  // either be fixed up already, or they will all be off by a single
-  // slide amount that is determined by finding the first segment
-  // that is at file offset zero which also has bytes (a file size
-  // that is greater than zero) in the object file.
+  // All sections listed in the dyld image info structure will all either
+  // be fixed up already, or they will all be off by a single slide amount
+  // that is determined by finding the first segment that is at file
+  // offset zero which also has bytes (a file size that is greater than
+  // zero) in the object file.
 
   // Determine the slide amount (if any)
   const size_t num_sections = dylib_info.segments.size();
   for (size_t i = 0; i < num_sections; ++i) {
-    // Iterate through the object file sections to find the
-    // first section that starts of file offset zero and that
-    // has bytes in the file...
+    // Iterate through the object file sections to find the first section
+    // that starts of file offset zero and that has bytes in the file...
     if ((dylib_info.segments[i].fileoff == 0 &&
          dylib_info.segments[i].filesize > 0) ||
         (dylib_info.segments[i].name == ConstString("__TEXT"))) {
       dylib_info.slide = dylib_info.address - dylib_info.segments[i].vmaddr;
-      // We have found the slide amount, so we can exit
-      // this for loop.
+      // We have found the slide amount, so we can exit this for loop.
       break;
     }
   }
@@ -981,14 +972,15 @@
       UpdateImageLoadAddress(exe_module_sp.get(), image_infos[exe_idx]);
 
       if (exe_module_sp.get() != target.GetExecutableModulePointer()) {
-        // Don't load dependent images since we are in dyld where we will know
-        // and find out about all images that are loaded. Also when setting the
-        // executable module, it will clear the targets module list, and if we
-        // have an in memory dyld module, it will get removed from the list
-        // so we will need to add it back after setting the executable module,
-        // so we first try and see if we already have a weak pointer to the
-        // dyld module, make it into a shared pointer, then add the executable,
-        // then re-add it back to make sure it is always in the list.
+        // Don't load dependent images since we are in dyld where we will
+        // know and find out about all images that are loaded. Also when
+        // setting the executable module, it will clear the targets module
+        // list, and if we have an in memory dyld module, it will get
+        // removed from the list so we will need to add it back after
+        // setting the executable module, so we first try and see if we
+        // already have a weak pointer to the dyld module, make it into a
+        // shared pointer, then add the executable, then re-add it back to
+        // make sure it is always in the list.
         ModuleSP dyld_module_sp(GetDYLDModule());
 
         const bool get_dependent_images = false;
@@ -1009,8 +1001,8 @@
 }
 
 //----------------------------------------------------------------------
-// Dump the _dyld_all_image_infos members and all current image infos
-// that we have parsed to the file handle provided.
+// Dump the _dyld_all_image_infos members and all current image infos that
+// we have parsed to the file handle provided.
 //----------------------------------------------------------------------
 void DynamicLoaderMacOSXDYLD::PutToLog(Log *log) const {
   if (log == NULL)
@@ -1039,10 +1031,10 @@
   if (m_break_id == LLDB_INVALID_BREAK_ID) {
     if (m_dyld_all_image_infos.notification != LLDB_INVALID_ADDRESS) {
       Address so_addr;
-      // Set the notification breakpoint and install a breakpoint
-      // callback function that will get called each time the
-      // breakpoint gets hit. We will use this to track when shared
-      // libraries get loaded/unloaded.
+      // Set the notification breakpoint and install a breakpoint callback
+      // function that will get called each time the breakpoint gets hit.
+      // We will use this to track when shared libraries get
+      // loaded/unloaded.
       bool resolved = m_process->GetTarget().ResolveLoadAddress(
           m_dyld_all_image_infos.notification, so_addr);
       if (!resolved) {
@@ -1071,14 +1063,14 @@
 
 Status DynamicLoaderMacOSXDYLD::CanLoadImage() {
   Status error;
-  // In order for us to tell if we can load a shared library we verify that
-  // the dylib_info_addr isn't zero (which means no shared libraries have
-  // been set yet, or dyld is currently mucking with the shared library list).
+  // In order for us to tell if we can load a shared library we verify
+  // that the dylib_info_addr isn't zero (which means no shared libraries
+  // have been set yet, or dyld is currently mucking with the shared
+  // library list).
   if (ReadAllImageInfosStructure()) {
     // TODO: also check the _dyld_global_lock_held variable in
-    // libSystem.B.dylib?
-    // TODO: check the malloc lock?
-    // TODO: check the objective C lock?
+    // libSystem.B.dylib? TODO: check the malloc lock? TODO: check the
+    // objective C lock?
     if (m_dyld_all_image_infos.dylib_info_addr != 0)
       return error; // Success
   }
@@ -1098,14 +1090,12 @@
   if (m_process) {
     addr_t all_image_infos = m_process->GetImageInfoAddress();
 
-    // The address returned by GetImageInfoAddress may be the address of dyld
-    // (don't want)
-    // or it may be the address of the dyld_all_image_infos structure (want).
-    // The first four
-    // bytes will be either the version field (all_image_infos) or a Mach-O file
-    // magic constant.
-    // Version 13 and higher of dyld_all_image_infos is required to get the
-    // sharedCacheUUID field.
+    // The address returned by GetImageInfoAddress may be the address of
+    // dyld (don't want) or it may be the address of the
+    // dyld_all_image_infos structure (want). The first four bytes will be
+    // either the version field (all_image_infos) or a Mach-O file magic
+    // constant. Version 13 and higher of dyld_all_image_infos is required
+    // to get the sharedCacheUUID field.
 
     Status err;
     uint32_t version_or_magic =
@@ -1153,10 +1143,9 @@
 
       //
       // add
-      // NB: sharedCacheBaseAddress is the next field in dyld_all_image_infos
-      // after
-      // sharedCacheUUID -- that is, 16 bytes after it, if we wanted to fetch
-      // it.
+      // NB: sharedCacheBaseAddress is the next field in
+      // dyld_all_image_infos after sharedCacheUUID -- that is, 16 bytes
+      // after it, if we wanted to fetch it.
     }
   }
   return false;
Index: source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp
===================================================================
--- source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp
+++ source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp
@@ -39,14 +39,14 @@
     return LLDB_INVALID_ADDRESS;
   }
 
-  // Try to get it from our process.  This might be a remote process and might
-  // grab it via some remote-specific mechanism.
+  // Try to get it from our process.  This might be a remote process and
+  // might grab it via some remote-specific mechanism.
   info_location = process->GetImageInfoAddress();
   if (log)
     log->Printf("%s info_location = 0x%" PRIx64, __FUNCTION__, info_location);
 
-  // If the process fails to return an address, fall back to seeing if the local
-  // object file can help us find it.
+  // If the process fails to return an address, fall back to seeing if the
+  // local object file can help us find it.
   if (info_location == LLDB_INVALID_ADDRESS) {
     Target *target = &process->GetTarget();
     if (target) {
@@ -191,18 +191,18 @@
     return false;
 
   // When the previous and current states are consistent this is the first
-  // time we have been asked to update.  Just take a snapshot of the currently
-  // loaded modules.
+  // time we have been asked to update.  Just take a snapshot of the
+  // currently loaded modules.
   if (m_previous.state == eConsistent && m_current.state == eConsistent)
     return fromRemote ? SaveSOEntriesFromRemote(module_list)
                       : TakeSnapshot(m_soentries);
 
-  // If we are about to add or remove a shared object clear out the current
-  // state and take a snapshot of the currently loaded images.
+  // If we are about to add or remove a shared object clear out the
+  // current state and take a snapshot of the currently loaded images.
   if (m_current.state == eAdd || m_current.state == eDelete) {
     // Some versions of the android dynamic linker might send two
-    // notifications with state == eAdd back to back. Ignore them
-    // until we get an eConsistent notification.
+    // notifications with state == eAdd back to back. Ignore them until we
+    // get an eConsistent notification.
     if (!(m_previous.state == eConsistent ||
           (m_previous.state == eAdd && m_current.state == eDelete)))
       return false;
@@ -217,8 +217,8 @@
   }
   assert(m_current.state == eConsistent);
 
-  // Otherwise check the previous state to determine what to expect and update
-  // accordingly.
+  // Otherwise check the previous state to determine what to expect and
+  // update accordingly.
   if (m_previous.state == eAdd)
     return fromRemote ? AddSOEntriesFromRemote(module_list) : AddSOEntries();
   else if (m_previous.state == eDelete)
@@ -376,8 +376,8 @@
 }
 
 bool DYLDRendezvous::SOEntryIsMainExecutable(const SOEntry &entry) {
-  // On some systes the executable is indicated by an empty path in the entry.
-  // On others it is the full path to the executable.
+  // On some systes the executable is indicated by an empty path in the
+  // entry. On others it is the full path to the executable.
 
   auto triple = m_process->GetTarget().GetArchitecture().GetTriple();
   switch (triple.getOS()) {
@@ -399,7 +399,8 @@
   if (m_current.map_addr == 0)
     return false;
 
-  // Clear previous entries since we are about to obtain an up to date list.
+  // Clear previous entries since we are about to obtain an up to date
+  // list.
   entry_list.clear();
 
   for (addr_t cursor = m_current.map_addr; cursor != 0; cursor = entry.next) {
@@ -448,14 +449,12 @@
   return str;
 }
 
-// Returns true if the load bias reported by the linker is incorrect for the
-// given entry. This
-// function is used to handle cases where we want to work around a bug in the
-// system linker.
+// Returns true if the load bias reported by the linker is incorrect for
+// the given entry. This function is used to handle cases where we want to
+// work around a bug in the system linker.
 static bool isLoadBiasIncorrect(Target &target, const std::string &file_path) {
-  // On Android L (API 21, 22) the load address of the "/system/bin/linker"
-  // isn't filled in
-  // correctly.
+  // On Android L (API 21, 22) the load address of the
+  // "/system/bin/linker" isn't filled in correctly.
   uint32_t os_major = 0, os_minor = 0, os_update = 0;
   if (target.GetArchitecture().GetTriple().isAndroid() &&
       target.GetPlatform()->GetOSVersion(os_major, os_minor, os_update) &&
@@ -470,9 +469,8 @@
 
 void DYLDRendezvous::UpdateBaseAddrIfNecessary(SOEntry &entry,
                                                std::string const &file_path) {
-  // If the load bias reported by the linker is incorrect then fetch the load
-  // address of the file
-  // from the proc file system.
+  // If the load bias reported by the linker is incorrect then fetch the
+  // load address of the file from the proc file system.
   if (isLoadBiasIncorrect(m_process->GetTarget(), file_path)) {
     lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
     bool is_loaded = false;
Index: source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
===================================================================
--- source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
+++ source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
@@ -155,8 +155,8 @@
 
     LoadAllCurrentModules();
     if (!SetRendezvousBreakpoint()) {
-      // If we cannot establish rendezvous breakpoint right now
-      // we'll try again at entry point.
+      // If we cannot establish rendezvous breakpoint right now we'll try
+      // again at entry point.
       ProbeEntry();
     }
 
@@ -199,8 +199,8 @@
                   __FUNCTION__);
 
     if (!SetRendezvousBreakpoint()) {
-      // If we cannot establish rendezvous breakpoint right now
-      // we'll try again at entry point.
+      // If we cannot establish rendezvous breakpoint right now we'll try
+      // again at entry point.
       ProbeEntry();
     }
 
@@ -258,12 +258,12 @@
   }
 }
 
-// The runtime linker has run and initialized the rendezvous structure once the
-// process has hit its entry point.  When we hit the corresponding breakpoint we
-// interrogate the rendezvous structure to get the load addresses of all
-// dependent modules for the process.  Similarly, we can discover the runtime
-// linker function and setup a breakpoint to notify us of any dynamically loaded
-// modules (via dlopen).
+// The runtime linker has run and initialized the rendezvous structure
+// once the process has hit its entry point.  When we hit the
+// corresponding breakpoint we interrogate the rendezvous structure to get
+// the load addresses of all dependent modules for the process.
+// Similarly, we can discover the runtime linker function and setup a
+// breakpoint to notify us of any dynamically loaded modules (via dlopen).
 bool DynamicLoaderPOSIXDYLD::EntryBreakpointHit(
     void *baton, StoppointCallbackContext *context, user_id_t break_id,
     user_id_t break_loc_id) {
@@ -280,14 +280,12 @@
                 dyld_instance->m_process ? dyld_instance->m_process->GetID()
                                          : LLDB_INVALID_PROCESS_ID);
 
-  // Disable the breakpoint --- if a stop happens right after this, which we've
-  // seen on occasion, we don't
-  // want the breakpoint stepping thread-plan logic to show a breakpoint
-  // instruction at the disassembled
-  // entry point to the program.  Disabling it prevents it.  (One-shot is not
-  // enough - one-shot removal logic
-  // only happens after the breakpoint goes public, which wasn't happening in
-  // our scenario).
+  // Disable the breakpoint --- if a stop happens right after this, which
+  // we've seen on occasion, we don't want the breakpoint stepping thread-
+  // plan logic to show a breakpoint instruction at the disassembled entry
+  // point to the program.  Disabling it prevents it.  (One-shot is not
+  // enough - one-shot removal logic only happens after the breakpoint
+  // goes public, which wasn't happening in our scenario).
   if (dyld_instance->m_process) {
     BreakpointSP breakpoint_sp =
         dyld_instance->m_process->GetTarget().GetBreakpointByID(break_id);
@@ -345,8 +343,8 @@
       return false;
     }
 
-    // Function names from different dynamic loaders that are known
-    // to be used as rendezvous between the loader and debuggers.
+    // Function names from different dynamic loaders that are known to be
+    // used as rendezvous between the loader and debuggers.
     static std::vector<std::string> DebugStateCandidates{
         "_dl_debug_state", "rtld_db_dlactivity", "__dl_rtld_db_dlactivity",
         "r_debug_state",   "_r_debug_state",     "_rtld_debug_state",
@@ -572,8 +570,8 @@
     return;
   }
 
-  // The rendezvous class doesn't enumerate the main module, so track
-  // that ourselves here.
+  // The rendezvous class doesn't enumerate the main module, so track that
+  // ourselves here.
   ModuleSP executable = GetTargetExecutable();
   m_loaded_modules[executable] = m_rendezvous.GetLinkMapAddress();
 
Index: source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.cpp
===================================================================
--- source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.cpp
+++ source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.cpp
@@ -19,9 +19,9 @@
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
-// Create an instance of this class. This function is filled into
-// the plugin info class that gets handed out by the plugin factory and
-// allows the lldb to instantiate an instance of this class.
+// Create an instance of this class. This function is filled into the
+// plugin info class that gets handed out by the plugin factory and allows
+// the lldb to instantiate an instance of this class.
 //----------------------------------------------------------------------
 DynamicLoader *DynamicLoaderStatic::CreateInstance(Process *process,
                                                    bool force) {
@@ -96,18 +96,18 @@
         SectionList *section_list = image_object_file->GetSectionList();
         if (section_list) {
           // All sections listed in the dyld image info structure will all
-          // either be fixed up already, or they will all be off by a single
-          // slide amount that is determined by finding the first segment
-          // that is at file offset zero which also has bytes (a file size
-          // that is greater than zero) in the object file.
+          // either be fixed up already, or they will all be off by a
+          // single slide amount that is determined by finding the first
+          // segment that is at file offset zero which also has bytes (a
+          // file size that is greater than zero) in the object file.
 
           // Determine the slide amount (if any)
           const size_t num_sections = section_list->GetSize();
           size_t sect_idx = 0;
           for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
-            // Iterate through the object file sections to find the
-            // first section that starts of file offset zero and that
-            // has bytes in the file...
+            // Iterate through the object file sections to find the first
+            // section that starts of file offset zero and that has bytes
+            // in the file...
             SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
             if (section_sp) {
               if (m_process->GetTarget().SetSectionLoadAddress(
Index: source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp
===================================================================
--- source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp
+++ source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp
@@ -96,9 +96,9 @@
     return ThreadPlanSP();
   }
 
-  // First instruction in a x86 Windows trampoline is going to be an indirect
-  // jump through the IAT and the next one will be a nop (usually there for
-  // alignment purposes). e.g.:
+  // First instruction in a x86 Windows trampoline is going to be an
+  // indirect jump through the IAT and the next one will be a nop (usually
+  // there for alignment purposes). e.g.:
   //     0x70ff4cfc <+956>: jmpl   *0x7100c2a8
   //     0x70ff4d02 <+962>: nop
 
Index: source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp
===================================================================
--- source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp
+++ source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp
@@ -225,9 +225,8 @@
     // No auxiliary variable necessary; expression returns void
     return true;
 
-  // In C++11, last_expr can be a LValueToRvalue implicit cast.  Strip that off
-  // if that's the
-  // case.
+  // In C++11, last_expr can be a LValueToRvalue implicit cast.  Strip
+  // that off if that's the case.
 
   do {
     ImplicitCastExpr *implicit_cast = dyn_cast<ImplicitCastExpr>(last_expr);
@@ -241,9 +240,9 @@
     last_expr = implicit_cast->getSubExpr();
   } while (0);
 
-  // is_lvalue is used to record whether the expression returns an assignable
-  // Lvalue or an
-  // Rvalue.  This is relevant because they are handled differently.
+  // is_lvalue is used to record whether the expression returns an
+  // assignable Lvalue or an Rvalue.  This is relevant because they are
+  // handled differently.
   //
   // For Lvalues
   //
Index: source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp
===================================================================
--- source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp
+++ source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp
@@ -33,8 +33,8 @@
 using namespace lldb_private;
 
 //------------------------------------------------------------------
-// Scoped class that will remove an active lexical decl from the set
-// when it goes out of scope.
+// Scoped class that will remove an active lexical decl from the set when
+// it goes out of scope.
 //------------------------------------------------------------------
 namespace {
 class ScopedLexicalDeclEraser {
@@ -65,10 +65,10 @@
   m_ast_context = &ast_context;
   m_file_manager = &file_manager;
   if (m_target->GetUseModernTypeLookup()) {
-    // Configure the ExternalASTMerger.  The merger needs to be able to import
-    // types from any source that we would do lookups in, which includes the
-    // persistent AST context as well as the modules and Objective-C runtime
-    // AST contexts.
+    // Configure the ExternalASTMerger.  The merger needs to be able to
+    // import types from any source that we would do lookups in, which
+    // includes the persistent AST context as well as the modules and
+    // Objective-C runtime AST contexts.
 
     lldbassert(!m_merger_up);
     clang::ExternalASTMerger::ImporterTarget target = {ast_context,
@@ -116,8 +116,9 @@
     } while (0);
 
     if (!is_shared_context) {
-      // Update the scratch AST context's merger to reflect any new sources we
-      // might have come across since the last time an expression was parsed.
+      // Update the scratch AST context's merger to reflect any new
+      // sources we might have come across since the last time an
+      // expression was parsed.
 
       auto scratch_ast_context = static_cast<ClangASTContextForExpressions*>(
           m_target->GetScratchClangASTContext());
@@ -140,9 +141,9 @@
   if (m_ast_importer_sp)
     m_ast_importer_sp->ForgetDestination(m_ast_context);
 
-  // We are in the process of destruction, don't create clang ast context on
-  // demand
-  // by passing false to Target::GetScratchClangASTContext(create_on_demand).
+  // We are in the process of destruction, don't create clang ast context
+  // on demand by passing false to
+  // Target::GetScratchClangASTContext(create_on_demand).
   ClangASTContext *scratch_clang_ast_context =
       m_target->GetScratchClangASTContext(false);
 
@@ -231,8 +232,9 @@
   }
 
   if (!GetLookupsEnabled()) {
-    // Wait until we see a '$' at the start of a name before we start doing
-    // any lookups so we can avoid lookup up all of the builtin types.
+    // Wait until we see a '$' at the start of a name before we start
+    // doing any lookups so we can avoid lookup up all of the builtin
+    // types.
     if (!decl_name.empty() && decl_name[0] == '$') {
       SetLookupsEnabled(true);
     } else {
@@ -397,9 +399,9 @@
         TagDecl *candidate_tag_decl =
             const_cast<TagDecl *>(tag_type->getDecl());
 
-        // We have found a type by basename and we need to make sure the decl
-        // contexts
-        // are the same before we can try to complete this type with another
+        // We have found a type by basename and we need to make sure the
+        // decl contexts are the same before we can try to complete this
+        // type with another
         if (!ClangASTContext::DeclsAreEquivalent(tag_decl, candidate_tag_decl))
           continue;
 
@@ -946,8 +948,8 @@
 
     if (!context.m_found.type) {
       do {
-        // Couldn't find any types elsewhere.  Try the Objective-C runtime if
-        // one exists.
+        // Couldn't find any types elsewhere.  Try the Objective-C runtime
+        // if one exists.
 
         lldb::ProcessSP process(m_target->GetProcessSP());
 
@@ -1242,9 +1244,9 @@
     if (sc_list.GetSize())
       break;
 
-    // Fall back and check for methods in categories.  If we find methods this
-    // way, we need to check that they're actually in
-    // categories on the desired class.
+    // Fall back and check for methods in categories.  If we find methods
+    // this way, we need to check that they're actually in categories on
+    // the desired class.
 
     SymbolContextList candidate_sc_list;
 
@@ -1349,8 +1351,8 @@
     if (!complete_interface_decl)
       break;
 
-    // We found the complete interface.  The runtime never needs to be queried
-    // in this scenario.
+    // We found the complete interface.  The runtime never needs to be
+    // queried in this scenario.
 
     DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl(
         complete_interface_decl);
@@ -1371,8 +1373,8 @@
   } while (0);
 
   do {
-    // Check the modules only if the debug information didn't have a complete
-    // interface.
+    // Check the modules only if the debug information didn't have a
+    // complete interface.
 
     if (ClangModulesDeclVendor *modules_decl_vendor =
             m_target->GetClangModulesDeclVendor()) {
@@ -1398,8 +1400,8 @@
   } while (0);
 
   do {
-    // Check the runtime only if the debug information didn't have a complete
-    // interface and the modules don't get us anywhere.
+    // Check the runtime only if the debug information didn't have a
+    // complete interface and the modules don't get us anywhere.
 
     lldb::ProcessSP process(m_target->GetProcessSP());
 
@@ -1531,8 +1533,8 @@
     if (!complete_interface_decl)
       break;
 
-    // We found the complete interface.  The runtime never needs to be queried
-    // in this scenario.
+    // We found the complete interface.  The runtime never needs to be
+    // queried in this scenario.
 
     DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl(
         complete_interface_decl);
@@ -1554,8 +1556,8 @@
   } while (0);
 
   do {
-    // Check the modules only if the debug information didn't have a complete
-    // interface.
+    // Check the modules only if the debug information didn't have a
+    // complete interface.
 
     ClangModulesDeclVendor *modules_decl_vendor =
         m_target->GetClangModulesDeclVendor();
@@ -1590,9 +1592,8 @@
   } while (0);
 
   do {
-    // Check the runtime only if the debug information didn't have a complete
-    // interface
-    // and nothing was in the modules.
+    // Check the runtime only if the debug information didn't have a
+    // complete interface and nothing was in the modules.
 
     lldb::ProcessSP process(m_target->GetProcessSP());
 
@@ -1643,14 +1644,12 @@
 static bool ImportOffsetMap(llvm::DenseMap<const D *, O> &destination_map,
                             llvm::DenseMap<const D *, O> &source_map,
                             ClangASTSource &source) {
-  // When importing fields into a new record, clang has a hard requirement that
-  // fields be imported in field offset order.  Since they are stored in a
-  // DenseMap
-  // with a pointer as the key type, this means we cannot simply iterate over
-  // the
-  // map, as the order will be non-deterministic.  Instead we have to sort by
-  // the offset
-  // and then insert in sorted order.
+  // When importing fields into a new record, clang has a hard requirement
+  // that fields be imported in field offset order.  Since they are stored
+  // in a DenseMap with a pointer as the key type, this means we cannot
+  // simply iterate over the map, as the order will be non-deterministic.
+  // Instead we have to sort by the offset and then insert in sorted
+  // order.
   typedef llvm::DenseMap<const D *, O> MapType;
   typedef typename MapType::value_type PairType;
   std::vector<PairType> sorted_items;
@@ -2012,7 +2011,8 @@
   } else if (m_merger_up) {
     return false; // Implement this correctly in ExternalASTMerger
   } else {
-    // this can happen early enough that no ExternalASTSource is installed.
+    // this can happen early enough that no ExternalASTSource is
+    // installed.
     return false;
   }
 }
@@ -2051,9 +2051,8 @@
 
   if (copied_qual_type.getAsOpaquePtr() &&
       copied_qual_type->getCanonicalTypeInternal().isNull())
-    // this shouldn't happen, but we're hardening because the AST importer seems
-    // to be generating bad types
-    // on occasion.
+    // this shouldn't happen, but we're hardening because the AST importer
+    // seems to be generating bad types on occasion.
     return CompilerType();
 
   return CompilerType(m_ast_context, copied_qual_type);
@@ -2128,8 +2127,8 @@
       isConstexprSpecified);
 
   // We have to do more than just synthesize the FunctionDecl.  We have to
-  // synthesize ParmVarDecls for all of the FunctionDecl's arguments.  To do
-  // this, we raid the function's FunctionProtoType for types.
+  // synthesize ParmVarDecls for all of the FunctionDecl's arguments.  To
+  // do this, we raid the function's FunctionProtoType for types.
 
   const FunctionProtoType *func_proto_type =
       qual_type.getTypePtr()->getAs<FunctionProtoType>();
@@ -2157,10 +2156,10 @@
   }
 
   // If this is an operator (e.g. operator new or operator==), only insert
-  // the declaration we inferred from the symbol if we can provide the correct
-  // number of arguments. We shouldn't really inject random decl(s) for
-  // functions that are analyzed semantically in a special way, otherwise we
-  // will crash in clang.
+  // the declaration we inferred from the symbol if we can provide the
+  // correct number of arguments. We shouldn't really inject random
+  // decl(s) for functions that are analyzed semantically in a special
+  // way, otherwise we will crash in clang.
   clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
   if (func_proto_type &&
       ClangASTContext::IsOperator(decl_name.getAsString().c_str(), op_kind)) {
Index: source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp
===================================================================
--- source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp
+++ source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp
@@ -74,7 +74,8 @@
 }
 
 ClangExpressionDeclMap::~ClangExpressionDeclMap() {
-  // Note: The model is now that the parser's AST context and all associated
+  // Note: The model is now that the parser's AST context and all
+  // associated
   //   data does not vanish until the expression has been executed.  This means
   //   that valuable lookup data (like namespaces) doesn't vanish, but
 
@@ -213,8 +214,8 @@
         m_exporter.getFromContext().getSourceManager().getFileID(loc);
     if (file != m_file)
       return false;
-    // We are assuming the Decl was parsed in this very expression, so it should
-    // not have external storage.
+    // We are assuming the Decl was parsed in this very expression, so it
+    // should not have external storage.
     lldbassert(!llvm::cast<DeclContext>(decl)->hasExternalLexicalStorage());
     return true;
   }
@@ -238,9 +239,9 @@
   Completer(clang::ASTImporter &exporter, clang::FileID file)
       : m_exporter(exporter), m_file(file) {}
   
-  // Implements the RecursiveASTVisitor's core API.  It is called on each Decl
-  // that the RecursiveASTVisitor encounters, and returns true if the traversal
-  // should continue.
+  // Implements the RecursiveASTVisitor's core API.  It is called on each
+  // Decl that the RecursiveASTVisitor encounters, and returns true if the
+  // traversal should continue.
   bool VisitDecl(clang::Decl *decl) {
     MaybeComplete(decl);
     return true;
@@ -457,8 +458,8 @@
                 static_cast<const void *>(decl), name.GetCString(),
                 var->GetName().GetCString());
 
-  // We know entity->m_parser_vars is valid because we used a parser variable
-  // to find it
+  // We know entity->m_parser_vars is valid because we used a parser
+  // variable to find it
 
   ClangExpressionVariable::ParserVars *parser_vars =
       llvm::cast<ClangExpressionVariable>(var)->GetParserVars(GetParserID());
@@ -977,16 +978,13 @@
           m_struct_vars->m_object_pointer_type = self_user_type;
         }
       } else {
-        // This branch will get hit if we are executing code in the context of a
-        // function that
-        // claims to have an object pointer (through DW_AT_object_pointer?) but
-        // is not formally a
-        // method of the class.  In that case, just look up the "this" variable
-        // in the current
-        // scope and use its type.
-        // FIXME: This code is formally correct, but clang doesn't currently
-        // emit DW_AT_object_pointer
-        // for C++ so it hasn't actually been tested.
+        // This branch will get hit if we are executing code in the
+        // context of a function that claims to have an object pointer
+        // (through DW_AT_object_pointer?) but is not formally a method of
+        // the class.  In that case, just look up the "this" variable in
+        // the current scope and use its type. FIXME: This code is
+        // formally correct, but clang doesn't currently emit
+        // DW_AT_object_pointer for C++ so it hasn't actually been tested.
 
         VariableList *vars = frame->GetVariableList(false);
 
@@ -1093,13 +1091,11 @@
 
         return;
       } else {
-        // This branch will get hit if we are executing code in the context of a
-        // function that
-        // claims to have an object pointer (through DW_AT_object_pointer?) but
-        // is not formally a
-        // method of the class.  In that case, just look up the "self" variable
-        // in the current
-        // scope and use its type.
+        // This branch will get hit if we are executing code in the
+        // context of a function that claims to have an object pointer
+        // (through DW_AT_object_pointer?) but is not formally a method of
+        // the class.  In that case, just look up the "self" variable in
+        // the current scope and use its type.
 
         VariableList *vars = frame->GetVariableList(false);
 
@@ -1216,10 +1212,9 @@
         for (size_t i = 0; i < vars->GetSize(); i++)
           vars->GetVariableAtIndex(i)->GetDecl();
 
-        // Search for declarations matching the name. Do not include imported
-        // decls
-        // in the search if we are looking for decls in the artificial namespace
-        // $__lldb_local_vars.
+        // Search for declarations matching the name. Do not include
+        // imported decls in the search if we are looking for decls in the
+        // artificial namespace $__lldb_local_vars.
         std::vector<CompilerDecl> found_decls =
             compiler_decl_context.FindDeclByName(name,
                                                  namespace_decl.IsValid());
@@ -1285,9 +1280,9 @@
                                         append, sc_list);
     }
 
-    // If we found more than one function, see if we can use the
-    // frame's decl context to remove functions that are shadowed
-    // by other functions which match in type but are nearer in scope.
+    // If we found more than one function, see if we can use the frame's
+    // decl context to remove functions that are shadowed by other
+    // functions which match in type but are nearer in scope.
     //
     // AddOneFunction will not add a function whose type has already been
     // added, so if there's another function in the list with a matching
@@ -1323,9 +1318,9 @@
 
         // First, symplify things by looping through the symbol contexts
         // to remove unwanted functions and separate out the functions we
-        // want to compare and prune into a separate list.
-        // Cache the info needed about the function declarations in a
-        // vector for efficiency.
+        // want to compare and prune into a separate list. Cache the info
+        // needed about the function declarations in a vector for
+        // efficiency.
         SymbolContextList sc_sym_list;
         uint32_t num_indices = sc_list.GetSize();
         std::vector<FuncDeclInfo> fdi_cache;
@@ -1335,16 +1330,16 @@
           SymbolContext sym_ctx;
           sc_list.GetContextAtIndex(index, sym_ctx);
 
-          // We don't know enough about symbols to compare them,
-          // but we should keep them in the list.
+          // We don't know enough about symbols to compare them, but we
+          // should keep them in the list.
           Function *function = sym_ctx.function;
           if (!function) {
             sc_sym_list.Append(sym_ctx);
             continue;
           }
           // Filter out functions without declaration contexts, as well as
-          // class/instance methods, since they'll be skipped in the
-          // code that follows anyway.
+          // class/instance methods, since they'll be skipped in the code
+          // that follows anyway.
           CompilerDeclContext func_decl_context = function->GetDeclContext();
           if (!func_decl_context ||
               func_decl_context.IsClassMethod(nullptr, nullptr, nullptr))
@@ -1364,10 +1359,10 @@
           fdi.m_decl_lvl = LLDB_INVALID_DECL_LEVEL;
           if (fdi.m_copied_type && func_decl_context) {
             // Call CountDeclLevels to get the number of parent scopes we
-            // have to look through before we find the function declaration.
-            // When comparing functions of the same type, the one with a
-            // lower count will be closer to us in the lookup scope and
-            // shadows the other.
+            // have to look through before we find the function
+            // declaration. When comparing functions of the same type, the
+            // one with a lower count will be closer to us in the lookup
+            // scope and shadows the other.
             clang::DeclContext *func_decl_ctx =
                 (clang::DeclContext *)func_decl_context.GetOpaqueDeclContext();
             fdi.m_decl_lvl = ast->CountDeclLevels(
@@ -1376,8 +1371,8 @@
           fdi_cache.emplace_back(fdi);
         }
 
-        // Loop through the functions in our cache looking for matching types,
-        // then compare their scope levels to see which is closer.
+        // Loop through the functions in our cache looking for matching
+        // types, then compare their scope levels to see which is closer.
         std::multimap<CompilerType, const FuncDeclInfo *> matches;
         for (const FuncDeclInfo &fdi : fdi_cache) {
           const CompilerType t = fdi.m_copied_type;
@@ -1393,7 +1388,8 @@
           matches.insert(std::make_pair(t, &fdi));
         }
 
-        // Loop through our matches and add their symbol contexts to our list.
+        // Loop through our matches and add their symbol contexts to our
+        // list.
         SymbolContextList sc_func_list;
         for (const auto &q : matches)
           sc_func_list.Append(q.second->m_sym_ctx);
@@ -1536,9 +1532,9 @@
     }
 
     if (target && !context.m_found.variable && !namespace_decl) {
-      // We couldn't find a non-symbol variable for this.  Now we'll hunt for
-      // a generic
-      // data symbol, and -- if it is found -- treat it as a variable.
+      // We couldn't find a non-symbol variable for this.  Now we'll hunt
+      // for a generic data symbol, and -- if it is found -- treat it as a
+      // variable.
       Status error;
 
       const Symbol *data_symbol =
@@ -2189,9 +2185,9 @@
   if (!type_source_info)
     return;
 
-  // Construct a typedef type because if "*this" is a templated type we can't
-  // just return ClassTemplateSpecializationDecls in response to name queries.
-  // Using a typedef makes this much more robust.
+  // Construct a typedef type because if "*this" is a templated type we
+  // can't just return ClassTemplateSpecializationDecls in response to
+  // name queries. Using a typedef makes this much more robust.
 
   TypedefDecl *typedef_decl = TypedefDecl::Create(
       *m_ast_context, m_ast_context->getTranslationUnitDecl(), SourceLocation(),
Index: source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp
===================================================================
--- source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp
+++ source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp
@@ -181,11 +181,10 @@
             new ClangDiagnostic(data, severity, Info.getID());
         m_manager->AddDiagnostic(new_diagnostic);
 
-        // Don't store away warning fixits, since the compiler doesn't have
-        // enough
-        // context in an expression for the warning to be useful.
-        // FIXME: Should we try to filter out FixIts that apply to our generated
-        // code, and not the user's expression?
+        // Don't store away warning fixits, since the compiler doesn't
+        // have enough context in an expression for the warning to be
+        // useful. FIXME: Should we try to filter out FixIts that apply to
+        // our generated code, and not the user's expression?
         if (severity == eDiagnosticSeverityError) {
           size_t num_fixit_hints = Info.getNumFixItHints();
           for (size_t i = 0; i < num_fixit_hints; i++) {
@@ -226,13 +225,11 @@
       m_code_generator(), m_pp_callbacks(nullptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-  // We can't compile expressions without a target.  So if the exe_scope is null
-  // or doesn't have a target,
-  // then we just need to get out of here.  I'll lldb_assert and not make any of
-  // the compiler objects since
-  // I can't return errors directly from the constructor.  Further calls will
-  // check if the compiler was made and
-  // bag out if it wasn't.
+  // We can't compile expressions without a target.  So if the exe_scope
+  // is null or doesn't have a target, then we just need to get out of
+  // here.  I'll lldb_assert and not make any of the compiler objects
+  // since I can't return errors directly from the constructor.  Further
+  // calls will check if the compiler was made and bag out if it wasn't.
 
   if (!exe_scope) {
     lldb_assert(exe_scope, "Can't make an expression parser with a null scope.",
@@ -263,7 +260,8 @@
   const auto target_machine = target_arch.GetMachine();
 
   // If the expression is being evaluated in the context of an existing
-  // stack frame, we introspect to see if the language runtime is available.
+  // stack frame, we introspect to see if the language runtime is
+  // available.
 
   lldb::StackFrameSP frame_sp = exe_scope->CalculateStackFrame();
   lldb::ProcessSP process_sp = exe_scope->CalculateProcess();
@@ -281,8 +279,7 @@
   }
 
   // 2. Configure the compiler with a set of default options that are
-  // appropriate
-  // for most situations.
+  // appropriate for most situations.
   if (target_arch.IsValid()) {
     std::string triple = target_arch.GetTriple().str();
     m_compiler->getTargetOpts().Triple = triple;
@@ -291,20 +288,19 @@
                   m_compiler->getTargetOpts().Triple.c_str());
   } else {
     // If we get here we don't have a valid target and just have to guess.
-    // Sometimes this will be ok to just use the host target triple (when we
-    // evaluate say "2+3", but other
-    // expressions like breakpoint conditions and other things that _are_ target
-    // specific really shouldn't just be
-    // using the host triple. In such a case the language runtime should expose
-    // an overridden options set (3),
+    // Sometimes this will be ok to just use the host target triple (when
+    // we evaluate say "2+3", but other expressions like breakpoint
+    // conditions and other things that _are_ target specific really
+    // shouldn't just be using the host triple. In such a case the
+    // language runtime should expose an overridden options set (3),
     // below.
     m_compiler->getTargetOpts().Triple = llvm::sys::getDefaultTargetTriple();
     if (log)
       log->Printf("Using default target triple of %s",
                   m_compiler->getTargetOpts().Triple.c_str());
   }
-  // Now add some special fixes for known architectures:
-  // Any arm32 iOS environment, but not on arm64
+  // Now add some special fixes for known architectures: Any arm32 iOS
+  // environment, but not on arm64
   if (m_compiler->getTargetOpts().Triple.find("arm64") == std::string::npos &&
       m_compiler->getTargetOpts().Triple.find("arm") != std::string::npos &&
       m_compiler->getTargetOpts().Triple.find("ios") != std::string::npos) {
@@ -317,9 +313,8 @@
     m_compiler->getTargetOpts().Features.push_back("+sse2");
   }
 
-  // Set the target CPU to generate code for.
-  // This will be empty for any CPU that doesn't really need to make a special
-  // CPU string.
+  // Set the target CPU to generate code for. This will be empty for any
+  // CPU that doesn't really need to make a special CPU string.
   m_compiler->getTargetOpts().CPU = target_arch.GetClangTargetCPU();
 
   // Set the target ABI
@@ -327,12 +322,11 @@
   if (!abi.empty())
     m_compiler->getTargetOpts().ABI = abi;
 
-  // 3. Now allow the runtime to provide custom configuration options for the
-  // target.
-  // In this case, a specialized language runtime is available and we can query
-  // it for extra options.
-  // For 99% of use cases, this will not be needed and should be provided when
-  // basic platform detection is not enough.
+  // 3. Now allow the runtime to provide custom configuration options for
+  // the target. In this case, a specialized language runtime is available
+  // and we can query it for extra options. For 99% of use cases, this
+  // will not be needed and should be provided when basic platform
+  // detection is not enough.
   if (lang_rt)
     overridden_target_opts =
         lang_rt->GetOverrideExprOptions(m_compiler->getTargetOpts());
@@ -376,26 +370,25 @@
   case lldb::eLanguageTypeC89:
   case lldb::eLanguageTypeC99:
   case lldb::eLanguageTypeC11:
-    // FIXME: the following language option is a temporary workaround,
-    // to "ask for C, get C++."
-    // For now, the expression parser must use C++ anytime the
-    // language is a C family language, because the expression parser
-    // uses features of C++ to capture values.
+    // FIXME: the following language option is a temporary workaround, to
+    // "ask for C, get C++." For now, the expression parser must use C++
+    // anytime the language is a C family language, because the expression
+    // parser uses features of C++ to capture values.
     m_compiler->getLangOpts().CPlusPlus = true;
     break;
   case lldb::eLanguageTypeObjC:
     m_compiler->getLangOpts().ObjC1 = true;
     m_compiler->getLangOpts().ObjC2 = true;
-    // FIXME: the following language option is a temporary workaround,
-    // to "ask for ObjC, get ObjC++" (see comment above).
+    // FIXME: the following language option is a temporary workaround, to
+    // "ask for ObjC, get ObjC++" (see comment above).
     m_compiler->getLangOpts().CPlusPlus = true;
 
-    // Clang now sets as default C++14 as the default standard (with
-    // GNU extensions), so we do the same here to avoid mismatches that
-    // cause compiler error when evaluating expressions (e.g. nullptr
-    // not found as it's a C++11 feature). Currently lldb evaluates
-    // C++14 as C++11 (see two lines below) so we decide to be consistent
-    // with that, but this could be re-evaluated in the future.
+    // Clang now sets as default C++14 as the default standard (with GNU
+    // extensions), so we do the same here to avoid mismatches that cause
+    // compiler error when evaluating expressions (e.g. nullptr not found
+    // as it's a C++11 feature). Currently lldb evaluates C++14 as C++11
+    // (see two lines below) so we decide to be consistent with that, but
+    // this could be re-evaluated in the future.
     m_compiler->getLangOpts().CPlusPlus11 = true;
     break;
   case lldb::eLanguageTypeC_plus_plus:
@@ -406,8 +399,8 @@
     LLVM_FALLTHROUGH;
   case lldb::eLanguageTypeC_plus_plus_03:
     m_compiler->getLangOpts().CPlusPlus = true;
-    // FIXME: the following language option is a temporary workaround,
-    // to "ask for C++, get ObjC++".  Apple hopes to remove this requirement
+    // FIXME: the following language option is a temporary workaround, to
+    // "ask for C++, get ObjC++".  Apple hopes to remove this requirement
     // on non-Apple platforms, but for now it is needed.
     m_compiler->getLangOpts().ObjC1 = true;
     break;
@@ -434,10 +427,9 @@
       ArchSpec(m_compiler->getTargetOpts().Triple.c_str())
           .CharIsSignedByDefault();
 
-  // Spell checking is a nice feature, but it ends up completing a
-  // lot of types that we didn't strictly speaking need to complete.
-  // As a result, we spend a long time parsing and importing debug
-  // information.
+  // Spell checking is a nice feature, but it ends up completing a lot of
+  // types that we didn't strictly speaking need to complete. As a result,
+  // we spend a long time parsing and importing debug information.
   m_compiler->getLangOpts().SpellChecking = false;
 
   if (process_sp && m_compiler->getLangOpts().ObjC1) {
@@ -481,8 +473,8 @@
 
   // Inform the target of the language options
   //
-  // FIXME: We shouldn't need to do this, the target should be immutable once
-  // created. This complexity should be lifted elsewhere.
+  // FIXME: We shouldn't need to do this, the target should be immutable
+  // once created. This complexity should be lifted elsewhere.
   m_compiler->getTarget().adjust(m_compiler->getLangOpts());
 
   // 6. Set up the diagnostic buffer for reporting errors
@@ -513,8 +505,8 @@
     m_compiler->getPreprocessor().addPPCallbacks(std::move(pp_callbacks));
   }
 
-  // 8. Most of this we get from the CompilerInstance, but we
-  // also want to give the context an ExternalASTSource.
+  // 8. Most of this we get from the CompilerInstance, but we also want to
+  // give the context an ExternalASTSource.
   m_selector_table.reset(new SelectorTable());
   m_builtin_context.reset(new Builtin::Context());
 
@@ -734,7 +726,8 @@
   else if (!editor.commit(commit))
     return false;
 
-  // Now play all the edits, and stash the result in the diagnostic manager.
+  // Now play all the edits, and stash the result in the diagnostic
+  // manager.
   editor.applyRewrites(rewrites_receiver);
   RewriteBuffer &main_file_buffer =
       rewriter.getEditBuffer(source_manager.getMainFileID());
Index: source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.cpp
===================================================================
--- source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.cpp
+++ source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.cpp
@@ -75,21 +75,22 @@
   if (m_compiled)
     return 0;
 
-  // Compilation might call code, make sure to keep on the thread the caller
-  // indicated.
+  // Compilation might call code, make sure to keep on the thread the
+  // caller indicated.
   ThreadList::ExpressionExecutionThreadPusher execution_thread_pusher(
       thread_to_use_sp);
 
-  // FIXME: How does clang tell us there's no return value?  We need to handle
-  // that case.
+  // FIXME: How does clang tell us there's no return value?  We need to
+  // handle that case.
   unsigned num_errors = 0;
 
   std::string return_type_str(
       m_function_return_type.GetTypeName().AsCString(""));
 
-  // Cons up the function we're going to wrap our call in, then compile it...
-  // We declare the function "extern "C"" because the compiler might be in C++
-  // mode which would mangle the name and then we couldn't find it again...
+  // Cons up the function we're going to wrap our call in, then compile
+  // it... We declare the function "extern "C"" because the compiler might
+  // be in C++ mode which would mangle the name and then we couldn't find
+  // it again...
   m_wrapper_function_text.clear();
   m_wrapper_function_text.append("extern \"C\" void ");
   m_wrapper_function_text.append(m_wrapper_function_name);
@@ -101,14 +102,11 @@
   m_wrapper_function_text.append(" (*fn_ptr) (");
 
   // Get the number of arguments.  If we have a function type and it is
-  // prototyped,
-  // trust that, otherwise use the values we were given.
-
-  // FIXME: This will need to be extended to handle Variadic functions.  We'll
-  // need
-  // to pull the defined arguments out of the function, then add the types from
-  // the
-  // arguments list for the variable arguments.
+  // prototyped, trust that, otherwise use the values we were given.
+
+  // FIXME: This will need to be extended to handle Variadic functions.
+  // We'll need to pull the defined arguments out of the function, then
+  // add the types from the arguments list for the variable arguments.
 
   uint32_t num_args = UINT32_MAX;
   bool trust_function = false;
Index: source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp
===================================================================
--- source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp
+++ source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp
@@ -40,9 +40,9 @@
 using namespace lldb_private;
 
 namespace {
-// Any Clang compiler requires a consumer for diagnostics.  This one stores them
-// as strings
-// so we can provide them to the user in case a module failed to load.
+// Any Clang compiler requires a consumer for diagnostics.  This one
+// stores them as strings so we can provide them to the user in case a
+// module failed to load.
 class StoringDiagnosticConsumer : public clang::DiagnosticConsumer {
 public:
   StoringDiagnosticConsumer();
@@ -61,9 +61,8 @@
   Log *m_log;
 };
 
-// The private implementation of our ClangModulesDeclVendor.  Contains all the
-// Clang state required
-// to load modules.
+// The private implementation of our ClangModulesDeclVendor.  Contains all
+// the Clang state required to load modules.
 class ClangModulesDeclVendorImpl : public ClangModulesDeclVendor {
 public:
   ClangModulesDeclVendorImpl(
@@ -562,9 +561,8 @@
 lldb_private::ClangModulesDeclVendor *
 ClangModulesDeclVendor::Create(Target &target) {
   // FIXME we should insure programmatically that the expression parser's
-  // compiler and the modules runtime's
-  // compiler are both initialized in the same way – preferably by the same
-  // code.
+  // compiler and the modules runtime's compiler are both initialized in
+  // the same way – preferably by the same code.
 
   if (!target.GetPlatform()->SupportsModules())
     return nullptr;
@@ -588,7 +586,8 @@
 
   compiler_invocation_arguments.push_back(ModuleImportBufferName);
 
-  // Add additional search paths with { "-I", path } or { "-F", path } here.
+  // Add additional search paths with { "-I", path } or { "-F", path }
+  // here.
 
   {
     llvm::SmallString<128> path;
Index: source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp
===================================================================
--- source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp
+++ source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp
@@ -195,13 +195,11 @@
     }
   } else if (clang::FunctionDecl *function_decl =
                  ClangASTContext::DeclContextGetAsFunctionDecl(decl_context)) {
-    // We might also have a function that said in the debug information that it
-    // captured an
-    // object pointer.  The best way to deal with getting to the ivars at
-    // present is by pretending
-    // that this is a method of a class in whatever runtime the debug info says
-    // the object pointer
-    // belongs to.  Do that here.
+    // We might also have a function that said in the debug information
+    // that it captured an object pointer.  The best way to deal with
+    // getting to the ivars at present is by pretending that this is a
+    // method of a class in whatever runtime the debug info says the
+    // object pointer belongs to.  Do that here.
 
     ClangASTMetadata *metadata =
         ClangASTContext::DeclContextGetMetaData(decl_context, function_decl);
@@ -291,10 +289,10 @@
   }
 }
 
-// This is a really nasty hack, meant to fix Objective-C expressions of the form
-// (int)[myArray count].  Right now, because the type information for count is
-// not available, [myArray count] returns id, which can't be directly cast to
-// int without causing a clang error.
+// This is a really nasty hack, meant to fix Objective-C expressions of
+// the form (int)[myArray count].  Right now, because the type information
+// for count is not available, [myArray count] returns id, which can't be
+// directly cast to int without causing a clang error.
 static void ApplyObjcCastHack(std::string &expr) {
 #define OBJC_CAST_HACK_FROM "(int)["
 #define OBJC_CAST_HACK_TO "(int)(long long)["
@@ -463,18 +461,16 @@
   if (!exe_scope)
     exe_scope = exe_ctx.GetTargetPtr();
 
-  // We use a shared pointer here so we can use the original parser - if it
-  // succeeds
-  // or the rewrite parser we might make if it fails.  But the parser_sp will
-  // never be empty.
+  // We use a shared pointer here so we can use the original parser - if
+  // it succeeds or the rewrite parser we might make if it fails.  But the
+  // parser_sp will never be empty.
 
   ClangExpressionParser parser(exe_scope, *this, generate_debug_info);
 
   unsigned num_errors = parser.Parse(diagnostic_manager);
 
-  // Check here for FixItHints.  If there are any try to apply the fixits and
-  // set the fixed text in m_fixed_text
-  // before returning an error.
+  // Check here for FixItHints.  If there are any try to apply the fixits
+  // and set the fixed text in m_fixed_text before returning an error.
   if (num_errors) {
     if (diagnostic_manager.HasFixIts()) {
       if (parser.RewriteExpression(diagnostic_manager)) {
@@ -496,8 +492,8 @@
   }
 
   //////////////////////////////////////////////////////////////////////////////////////////
-  // Prepare the output of the parser for execution, evaluating it statically if
-  // possible
+  // Prepare the output of the parser for execution, evaluating it
+  // statically if possible
   //
 
   {
@@ -540,9 +536,9 @@
       register_execution_unit = true;
     }
 
-    // If there is more than one external function in the execution
-    // unit, it needs to keep living even if it's not top level, because
-    // the result could refer to that function.
+    // If there is more than one external function in the execution unit,
+    // it needs to keep living even if it's not top level, because the
+    // result could refer to that function.
 
     if (m_execution_unit_sp->GetJittedFunctions().size() > 1) {
       register_execution_unit = true;
Index: source/Plugins/ExpressionParser/Clang/IRForTarget.cpp
===================================================================
--- source/Plugins/ExpressionParser/Clang/IRForTarget.cpp
+++ source/Plugins/ExpressionParser/Clang/IRForTarget.cpp
@@ -160,7 +160,8 @@
   if (!m_resolve_vars)
     return true;
 
-  // Find the result variable.  If it doesn't exist, we can give up right here.
+  // Find the result variable.  If it doesn't exist, we can give up right
+  // here.
 
   ValueSymbolTable &value_symbol_table = m_module->getValueSymbolTable();
 
@@ -263,8 +264,7 @@
   }
 
   // Get the next available result name from m_decl_map and create the
-  // persistent
-  // variable for it
+  // persistent variable for it
 
   // If the result is an Lvalue, it is emitted as a pointer; see
   // ASTResultSynthesizer::SynthesizeBodyResult.
@@ -345,12 +345,12 @@
       GlobalValue::ExternalLinkage, NULL, /* no initializer */
       m_result_name.GetCString());
 
-  // It's too late in compilation to create a new VarDecl for this, but we don't
-  // need to.  We point the metadata at the old VarDecl.  This creates an odd
-  // anomaly: a variable with a Value whose name is something like $0 and a
-  // Decl whose name is $__lldb_expr_result.  This condition is handled in
-  // ClangExpressionDeclMap::DoMaterialize, and the name of the variable is
-  // fixed up.
+  // It's too late in compilation to create a new VarDecl for this, but we
+  // don't need to.  We point the metadata at the old VarDecl.  This
+  // creates an odd anomaly: a variable with a Value whose name is
+  // something like $0 and a Decl whose name is $__lldb_expr_result.  This
+  // condition is handled in ClangExpressionDeclMap::DoMaterialize, and
+  // the name of the variable is fixed up.
 
   ConstantInt *new_constant_int =
       ConstantInt::get(llvm::Type::getInt64Ty(m_module->getContext()),
@@ -463,10 +463,8 @@
     // CFStringRef -> i8*
     // CFAllocatorRef -> i8*
     // UInt8 * -> i8*
-    // CFIndex -> long (i32 or i64, as appropriate; we ask the module for its
-    // pointer size for now)
-    // CFStringEncoding -> i32
-    // Boolean -> i8
+    // CFIndex -> long (i32 or i64, as appropriate; we ask the module for
+    // its pointer size for now) CFStringEncoding -> i32 Boolean -> i8
 
     Type *arg_type_array[5];
 
@@ -740,8 +738,8 @@
         if (log)
           log->PutCString("Error rewriting the constant string");
 
-        // We don't print an error message here because RewriteObjCConstString
-        // has done so for us.
+        // We don't print an error message here because
+        // RewriteObjCConstString has done so for us.
 
         return false;
       }
@@ -798,12 +796,12 @@
   if (!load)
     return false;
 
-  // Unpack the message name from the selector.  In LLVM IR, an objc_msgSend
-  // gets represented as
+  // Unpack the message name from the selector.  In LLVM IR, an
+  // objc_msgSend gets represented as
   //
-  // %tmp     = load i8** @"OBJC_SELECTOR_REFERENCES_" ; <i8*>
-  // %call    = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %obj, i8* %tmp, ...)
-  // ; <i8*>
+  // %tmp     = load i8** @"OBJC_SELECTOR_REFERENCES_" ; <i8*> %call    =
+  // call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %obj, i8* %tmp, ...) ;
+  // <i8*>
   //
   // where %obj is the object pointer and %tmp is the selector.
   //
@@ -811,8 +809,8 @@
   // @"\01L_OBJC_llvm_moduleETH_VAR_NAllvm_moduleE_".
   // @"\01L_OBJC_llvm_moduleETH_VAR_NAllvm_moduleE_" contains the string.
 
-  // Find the pointer's initializer (a ConstantExpr with opcode GetElementPtr)
-  // and get the string from its target
+  // Find the pointer's initializer (a ConstantExpr with opcode
+  // GetElementPtr) and get the string from its target
 
   GlobalVariable *_objc_selector_references_ =
       dyn_cast<GlobalVariable>(load->getPointerOperand());
@@ -834,7 +832,8 @@
   if (!osr_initializer_base)
     return false;
 
-  // Find the string's initializer (a ConstantArray) and get the string from it
+  // Find the string's initializer (a ConstantArray) and get the string
+  // from it
 
   GlobalVariable *_objc_meth_var_name_ =
       dyn_cast<GlobalVariable>(osr_initializer_base);
@@ -870,12 +869,13 @@
       log->Printf("Found sel_registerName at 0x%" PRIx64,
                   sel_registerName_addr);
 
-    // Build the function type: struct objc_selector *sel_registerName(uint8_t*)
+    // Build the function type: struct objc_selector
+    // *sel_registerName(uint8_t*)
 
-    // The below code would be "more correct," but in actuality what's required
-    // is uint8_t*
-    // Type *sel_type = StructType::get(m_module->getContext());
-    // Type *sel_ptr_type = PointerType::getUnqual(sel_type);
+    // The below code would be "more correct," but in actuality what's
+    // required is uint8_t* Type *sel_type =
+    // StructType::get(m_module->getContext()); Type *sel_ptr_type =
+    // PointerType::getUnqual(sel_type);
     Type *sel_ptr_type = Type::getInt8PtrTy(m_module->getContext());
 
     Type *type_array[1];
@@ -973,15 +973,14 @@
   if (!load)
     return false;
 
-  // Unpack the class name from the reference.  In LLVM IR, a reference to an
-  // Objective-C class gets represented as
+  // Unpack the class name from the reference.  In LLVM IR, a reference to
+  // an Objective-C class gets represented as
   //
   // %tmp     = load %struct._objc_class*,
   //            %struct._objc_class** @OBJC_CLASS_REFERENCES_, align 4
   //
   // @"OBJC_CLASS_REFERENCES_ is a bitcast of a character array called
-  // @OBJC_CLASS_NAME_.
-  // @OBJC_CLASS_NAME contains the string.
+  // @OBJC_CLASS_NAME_. @OBJC_CLASS_NAME contains the string.
 
   // Find the pointer's initializer (a ConstantExpr with opcode BitCast)
   // and get the string from its target
@@ -1006,7 +1005,8 @@
   if (!ocr_initializer_base)
     return false;
 
-  // Find the string's initializer (a ConstantArray) and get the string from it
+  // Find the string's initializer (a ConstantArray) and get the string
+  // from it
 
   GlobalVariable *_objc_class_name_ =
       dyn_cast<GlobalVariable>(ocr_initializer_base);
@@ -1137,7 +1137,8 @@
   if (!constant_int)
     return false;
 
-  // We attempt to register this as a new persistent variable with the DeclMap.
+  // We attempt to register this as a new persistent variable with the
+  // DeclMap.
 
   uintptr_t ptr = constant_int->getZExtValue();
 
@@ -1159,8 +1160,8 @@
       GlobalValue::ExternalLinkage, NULL,   /* no initializer */
       alloc->getName().str());
 
-  // What we're going to do here is make believe this was a regular old external
-  // variable.  That means we need to make the metadata valid.
+  // What we're going to do here is make believe this was a regular old
+  // external variable.  That means we need to make the metadata valid.
 
   NamedMDNode *named_metadata =
       m_module->getOrInsertNamedMetadata("clang.global.decl.ptrs");
@@ -1174,9 +1175,8 @@
   MDNode *persistent_global_md = MDNode::get(m_module->getContext(), value_ref);
   named_metadata->addOperand(persistent_global_md);
 
-  // Now, since the variable is a pointer variable, we will drop in a load of
-  // that
-  // pointer variable.
+  // Now, since the variable is a pointer variable, we will drop in a load
+  // of that pointer variable.
 
   LoadInst *persistent_load = new LoadInst(persistent_global, "", alloc);
 
@@ -1365,17 +1365,16 @@
     const Type *value_type = NULL;
 
     if (name[0] == '$') {
-      // The $__lldb_expr_result name indicates the return value has allocated
-      // as
-      // a static variable.  Per the comment at
-      // ASTResultSynthesizer::SynthesizeBodyResult,
-      // accesses to this static variable need to be redirected to the result of
-      // dereferencing
-      // a pointer that is passed in as one of the arguments.
+      // The $__lldb_expr_result name indicates the return value has
+      // allocated as a static variable.  Per the comment at
+      // ASTResultSynthesizer::SynthesizeBodyResult, accesses to this
+      // static variable need to be redirected to the result of
+      // dereferencing a pointer that is passed in as one of the
+      // arguments.
       //
-      // Consequently, when reporting the size of the type, we report a pointer
-      // type pointing
-      // to the type of $__lldb_expr_result, not the type itself.
+      // Consequently, when reporting the size of the type, we report a
+      // pointer type pointing to the type of $__lldb_expr_result, not the
+      // type itself.
       //
       // We also do this for any user-declared persistent variables.
       compiler_type = compiler_type.GetPointerType();
@@ -1541,7 +1540,8 @@
 
     CallInst *call = dyn_cast<CallInst>(&inst);
 
-    // MaybeHandleCallArguments handles error reporting; we are silent here
+    // MaybeHandleCallArguments handles error reporting; we are silent
+    // here
     if (!call)
       continue;
 
@@ -1582,7 +1582,8 @@
 
     CallInst *call = dyn_cast<CallInst>(&inst);
 
-    // MaybeHandleCallArguments handles error reporting; we are silent here
+    // MaybeHandleCallArguments handles error reporting; we are silent
+    // here
     if (call && !MaybeHandleCallArguments(call))
       return false;
   }
@@ -1721,8 +1722,8 @@
                                  lldb_private::Stream &error_stream) {
   SmallVector<User *, 16> users;
 
-  // We do this because the use list might change, invalidating our iterator.
-  // Much better to keep a work list ourselves.
+  // We do this because the use list might change, invalidating our
+  // iterator. Much better to keep a work list ourselves.
   for (llvm::User *u : old_constant->users())
     users.push_back(u);
 
@@ -1965,12 +1966,12 @@
       FunctionValueCache body_result_maker(
           [this, name, offset_type, offset, argument,
            value](llvm::Function *function) -> llvm::Value * {
-            // Per the comment at ASTResultSynthesizer::SynthesizeBodyResult, in
-            // cases where the result
-            // variable is an rvalue, we have to synthesize a dereference of the
-            // appropriate structure
-            // entry in order to produce the static variable that the AST thinks
-            // it is accessing.
+            // Per the comment at
+            // ASTResultSynthesizer::SynthesizeBodyResult, in cases where
+            // the result variable is an rvalue, we have to synthesize a
+            // dereference of the appropriate structure entry in order to
+            // produce the static variable that the AST thinks it is
+            // accessing.
 
             llvm::Instruction *entry_instruction = llvm::cast<Instruction>(
                 m_entry_instruction_finder.GetValue(function));
@@ -2112,7 +2113,8 @@
       if (log)
         log->Printf("CreateResultVariable() failed");
 
-      // CreateResultVariable() reports its own errors, so we don't do so here
+      // CreateResultVariable() reports its own errors, so we don't do so
+      // here
 
       return false;
     }
@@ -2153,8 +2155,8 @@
         if (log)
           log->Printf("RewritePersistentAllocs() failed");
 
-        // RewritePersistentAllocs() reports its own errors, so we don't do so
-        // here
+        // RewritePersistentAllocs() reports its own errors, so we don't
+        // do so here
 
         return false;
       }
@@ -2163,7 +2165,8 @@
         if (log)
           log->Printf("RemoveCXAAtExit() failed");
 
-        // RemoveCXAAtExit() reports its own errors, so we don't do so here
+        // RemoveCXAAtExit() reports its own errors, so we don't do so
+        // here
 
         return false;
       }
@@ -2171,14 +2174,16 @@
   }
 
   ///////////////////////////////////////////////////////////////////////////////
-  // Fix all Objective-C constant strings to use NSStringWithCString:encoding:
+  // Fix all Objective-C constant strings to use
+  // NSStringWithCString:encoding:
   //
 
   if (!RewriteObjCConstStrings()) {
     if (log)
       log->Printf("RewriteObjCConstStrings() failed");
 
-    // RewriteObjCConstStrings() reports its own errors, so we don't do so here
+    // RewriteObjCConstStrings() reports its own errors, so we don't do so
+    // here
 
     return false;
   }
@@ -2194,7 +2199,8 @@
         if (log)
           log->Printf("RewriteObjCSelectors() failed");
 
-        // RewriteObjCSelectors() reports its own errors, so we don't do so here
+        // RewriteObjCSelectors() reports its own errors, so we don't do
+        // so here
 
         return false;
       }
@@ -2203,7 +2209,8 @@
         if (log)
           log->Printf("RewriteObjCClassReferences() failed");
 
-        // RewriteObjCClasses() reports its own errors, so we don't do so here
+        // RewriteObjCClasses() reports its own errors, so we don't do so
+        // here
 
         return false;
       }
Index: source/Plugins/ExpressionParser/Go/GoUserExpression.cpp
===================================================================
--- source/Plugins/ExpressionParser/Go/GoUserExpression.cpp
+++ source/Plugins/ExpressionParser/Go/GoUserExpression.cpp
@@ -400,9 +400,8 @@
       if (var_sp)
         val = m_frame->GetValueObjectForFrameVariable(var_sp, m_use_dynamic);
       else {
-        // When a variable is on the heap instead of the stack, go records a
-        // variable
-        // '&x' instead of 'x'.
+        // When a variable is on the heap instead of the stack, go records
+        // a variable '&x' instead of 'x'.
         var_sp = var_list_sp->FindVariable(ConstString("&" + varname));
         if (var_sp) {
           val = m_frame->GetValueObjectForFrameVariable(var_sp, m_use_dynamic);
Index: source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp
===================================================================
--- source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp
+++ source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp
@@ -258,8 +258,8 @@
     reg_info.name = "f7";
     break;
 
-  // Intel wireless MMX general purpose registers 0 - 7
-  // XScale accumulator register 0 - 7 (they do overlap with wCGR0 - wCGR7)
+  // Intel wireless MMX general purpose registers 0 - 7 XScale accumulator
+  // register 0 - 7 (they do overlap with wCGR0 - wCGR7)
   case dwarf_wCGR0:
     reg_info.name = "wCGR0/ACC0";
     break;
@@ -602,7 +602,8 @@
 }
 
 // A8.6.50
-// Valid return values are {1, 2, 3, 4}, with 0 signifying an error condition.
+// Valid return values are {1, 2, 3, 4}, with 0 signifying an error
+// condition.
 static uint32_t CountITSize(uint32_t ITMask) {
   // First count the trailing zeros of the IT mask.
   uint32_t TZ = llvm::countTrailingZeros(ITMask);
@@ -767,8 +768,8 @@
   return false;
 }
 
-// Write "bits (32) UNKNOWN" to memory address "address".  Helper function for
-// many ARM instructions.
+// Write "bits (32) UNKNOWN" to memory address "address".  Helper function
+// for many ARM instructions.
 bool EmulateInstructionARM::WriteBits32UnknownToMemory(addr_t address) {
   EmulateInstruction::Context context;
   context.type = EmulateInstruction::eContextWriteMemoryRandomBits;
@@ -900,9 +901,9 @@
   return fp_regnum;
 }
 
-// Push Multiple Registers stores multiple registers to the stack, storing to
-// consecutive memory locations ending just below the address in SP, and updates
-// SP to point to the start of the stored data.
+// Push Multiple Registers stores multiple registers to the stack, storing
+// to consecutive memory locations ending just below the address in SP,
+// and updates SP to point to the start of the stored data.
 bool EmulateInstructionARM::EmulatePUSH(const uint32_t opcode,
                                         const ARMEncoding encoding) {
 #if 0
@@ -1022,9 +1023,9 @@
   return true;
 }
 
-// Pop Multiple Registers loads multiple registers from the stack, loading from
-// consecutive memory locations staring at the address in SP, and updates
-// SP to point just above the loaded data.
+// Pop Multiple Registers loads multiple registers from the stack, loading
+// from consecutive memory locations staring at the address in SP, and
+// updates SP to point just above the loaded data.
 bool EmulateInstructionARM::EmulatePOP(const uint32_t opcode,
                                        const ARMEncoding encoding) {
 #if 0
@@ -1151,8 +1152,8 @@
   return true;
 }
 
-// Set r7 or ip to point to saved value residing within the stack.
-// ADD (SP plus immediate)
+// Set r7 or ip to point to saved value residing within the stack. ADD (SP
+// plus immediate)
 bool EmulateInstructionARM::EmulateADDRdSPImm(const uint32_t opcode,
                                               const ARMEncoding encoding) {
 #if 0
@@ -1212,8 +1213,7 @@
   return true;
 }
 
-// Set r7 or ip to the current stack pointer.
-// MOV (register)
+// Set r7 or ip to the current stack pointer. MOV (register)
 bool EmulateInstructionARM::EmulateMOVRdSP(const uint32_t opcode,
                                            const ARMEncoding encoding) {
 #if 0
@@ -1267,8 +1267,8 @@
   return true;
 }
 
-// Move from high register (r8-r15) to low register (r0-r7).
-// MOV (register)
+// Move from high register (r8-r15) to low register (r0-r7). MOV
+// (register)
 bool EmulateInstructionARM::EmulateMOVLowHigh(const uint32_t opcode,
                                               const ARMEncoding encoding) {
   return EmulateMOVRdRm(opcode, encoding);
@@ -1362,9 +1362,9 @@
   return true;
 }
 
-// Move (immediate) writes an immediate value to the destination register.  It
-// can optionally update the condition flags based on the value.
-// MOV (immediate)
+// Move (immediate) writes an immediate value to the destination register.
+// It can optionally update the condition flags based on the value. MOV
+// (immediate)
 bool EmulateInstructionARM::EmulateMOVRdImm(const uint32_t opcode,
                                             const ARMEncoding encoding) {
 #if 0
@@ -1412,8 +1412,8 @@
       break;
 
     case eEncodingT3: {
-      // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(imm4:i:imm3:imm8,
-      // 32);
+      // d = UInt(Rd); setflags = FALSE; imm32 =
+      // ZeroExtend(imm4:i:imm3:imm8, 32);
       Rd = Bits32(opcode, 11, 8);
       setflags = false;
       uint32_t imm4 = Bits32(opcode, 19, 16);
@@ -1442,7 +1442,8 @@
       break;
 
     case eEncodingA2: {
-      // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(imm4:imm12, 32);
+      // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(imm4:imm12,
+      // 32);
       Rd = Bits32(opcode, 15, 12);
       setflags = false;
       uint32_t imm4 = Bits32(opcode, 19, 16);
@@ -1470,15 +1471,14 @@
   return true;
 }
 
-// MUL multiplies two register values.  The least significant 32 bits of the
-// result are written to the destination
-// register.  These 32 bits do not depend on whether the source register values
-// are considered to be signed values or
-// unsigned values.
+// MUL multiplies two register values.  The least significant 32 bits of
+// the result are written to the destination register.  These 32 bits do
+// not depend on whether the source register values are considered to be
+// signed values or unsigned values.
 //
-// Optionally, it can update the condition flags based on the result.  In the
-// Thumb instruction set, this option is
-// limited to only a few forms of the instruction.
+// Optionally, it can update the condition flags based on the result.  In
+// the Thumb instruction set, this option is limited to only a few forms
+// of the instruction.
 bool EmulateInstructionARM::EmulateMUL(const uint32_t opcode,
                                        const ARMEncoding encoding) {
 #if 0
@@ -1506,7 +1506,8 @@
     // EncodingSpecificOperations();
     switch (encoding) {
     case eEncodingT1:
-      // d = UInt(Rdm); n = UInt(Rn); m = UInt(Rdm); setflags = !InITBlock();
+      // d = UInt(Rdm); n = UInt(Rn); m = UInt(Rdm); setflags =
+      // !InITBlock();
       d = Bits32(opcode, 2, 0);
       n = Bits32(opcode, 5, 3);
       m = Bits32(opcode, 2, 0);
@@ -1554,15 +1555,15 @@
 
     bool success = false;
 
-    // operand1 = SInt(R[n]); // operand1 = UInt(R[n]) produces the same final
-    // results
+    // operand1 = SInt(R[n]); // operand1 = UInt(R[n]) produces the same
+    // final results
     uint64_t operand1 =
         ReadRegisterUnsigned(eRegisterKindDWARF, dwarf_r0 + n, 0, &success);
     if (!success)
       return false;
 
-    // operand2 = SInt(R[m]); // operand2 = UInt(R[m]) produces the same final
-    // results
+    // operand2 = SInt(R[m]); // operand2 = UInt(R[m]) produces the same
+    // final results
     uint64_t operand2 =
         ReadRegisterUnsigned(eRegisterKindDWARF, dwarf_r0 + m, 0, &success);
     if (!success)
@@ -1605,9 +1606,9 @@
   return true;
 }
 
-// Bitwise NOT (immediate) writes the bitwise inverse of an immediate value to
-// the destination register.
-// It can optionally update the condition flags based on the value.
+// Bitwise NOT (immediate) writes the bitwise inverse of an immediate
+// value to the destination register. It can optionally update the
+// condition flags based on the value.
 bool EmulateInstructionARM::EmulateMVNImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -1665,9 +1666,9 @@
   return true;
 }
 
-// Bitwise NOT (register) writes the bitwise inverse of a register value to the
-// destination register.
-// It can optionally update the condition flags based on the result.
+// Bitwise NOT (register) writes the bitwise inverse of a register value
+// to the destination register. It can optionally update the condition
+// flags based on the result.
 bool EmulateInstructionARM::EmulateMVNReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -1746,9 +1747,8 @@
   return true;
 }
 
-// PC relative immediate load into register, possibly followed by ADD (SP plus
-// register).
-// LDR (literal)
+// PC relative immediate load into register, possibly followed by ADD (SP
+// plus register). LDR (literal)
 bool EmulateInstructionARM::EmulateLDRRtPCRelative(const uint32_t opcode,
                                                    const ARMEncoding encoding) {
 #if 0
@@ -1868,7 +1868,8 @@
     bool setflags;
     switch (encoding) {
     case eEncodingT1:
-      // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(imm8:'00', 32);
+      // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(imm8:'00',
+      // 32);
       d = Bits32(opcode, 10, 8);
       imm32 = (Bits32(opcode, 7, 0) << 2);
       setflags = false;
@@ -1899,7 +1900,8 @@
 
     case eEncodingT4: {
       // if Rn == '1111' then SEE ADR;
-      // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(i:imm3:imm8, 32);
+      // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(i:imm3:imm8,
+      // 32);
       d = Bits32(opcode, 11, 8);
       setflags = false;
       uint32_t i = Bit32(opcode, 26);
@@ -2005,10 +2007,9 @@
   return true;
 }
 
-// Branch with Link and Exchange Instruction Sets (immediate) calls a subroutine
-// at a PC-relative address, and changes instruction set from ARM to Thumb, or
-// from Thumb to ARM.
-// BLX (immediate)
+// Branch with Link and Exchange Instruction Sets (immediate) calls a
+// subroutine at a PC-relative address, and changes instruction set from
+// ARM to Thumb, or from Thumb to ARM. BLX (immediate)
 bool EmulateInstructionARM::EmulateBLXImmediate(const uint32_t opcode,
                                                 const ARMEncoding encoding) {
 #if 0
@@ -2110,9 +2111,8 @@
   return true;
 }
 
-// Branch with Link and Exchange (register) calls a subroutine at an address and
-// instruction set specified by a register.
-// BLX (register)
+// Branch with Link and Exchange (register) calls a subroutine at an
+// address and instruction set specified by a register. BLX (register)
 bool EmulateInstructionARM::EmulateBLXRm(const uint32_t opcode,
                                          const ARMEncoding encoding) {
 #if 0
@@ -2220,9 +2220,8 @@
 }
 
 // Branch and Exchange Jazelle attempts to change to Jazelle state. If the
-// attempt fails, it branches to an
-// address and instruction set specified by a register as though it were a BX
-// instruction.
+// attempt fails, it branches to an address and instruction set specified
+// by a register as though it were a BX instruction.
 //
 // TODO: Emulate Jazelle architecture?
 //       We currently assume that switching to Jazelle state fails, thus
@@ -2378,11 +2377,11 @@
   return true;
 }
 
-// This instruction subtracts an immediate value from the SP value, and writes
-// the result to the destination register.
+// This instruction subtracts an immediate value from the SP value, and
+// writes the result to the destination register.
 //
-// If Rd == 13 => A sub operation to adjust the SP -- allocate space for local
-// storage.
+// If Rd == 13 => A sub operation to adjust the SP -- allocate space for
+// local storage.
 bool EmulateInstructionARM::EmulateSUBSPImm(const uint32_t opcode,
                                             const ARMEncoding encoding) {
 #if 0
@@ -2561,8 +2560,8 @@
   return true;
 }
 
-// Vector Push stores multiple extension registers to the stack.
-// It also updates SP to point to the start of the stored data.
+// Vector Push stores multiple extension registers to the stack. It also
+// updates SP to point to the start of the stored data.
 bool EmulateInstructionARM::EmulateVPUSH(const uint32_t opcode,
                                          const ARMEncoding encoding) {
 #if 0
@@ -2577,7 +2576,8 @@
                 MemA[address,4] = S[d+r]; address = address+4;
         else
             for r = 0 to regs-1
-                // Store as two word-aligned words in the correct order for current endianness.
+                // Store as two word-aligned words in the correct order
+                // for current endianness.
                 MemA[address,4] = if BigEndian() then D[d+r]<63:32> else D[d+r]<31:0>;
                 MemA[address+4,4] = if BigEndian() then D[d+r]<31:0> else D[d+r]<63:32>;
                 address = address+8;
@@ -2653,8 +2653,8 @@
   return true;
 }
 
-// Vector Pop loads multiple extension registers from the stack.
-// It also updates SP to point just above the loaded data.
+// Vector Pop loads multiple extension registers from the stack. It also
+// updates SP to point just above the loaded data.
 bool EmulateInstructionARM::EmulateVPOP(const uint32_t opcode,
                                         const ARMEncoding encoding) {
 #if 0
@@ -2670,7 +2670,8 @@
         else
             for r = 0 to regs-1
                 word1 = MemA[address,4]; word2 = MemA[address+4,4]; address = address+8;
-                // Combine the word-aligned words in the correct order for current endianness.
+                // Combine the word-aligned words in the correct order for
+                // current endianness.
                 D[d+r] = if BigEndian() then word1:word2 else word2:word1;
     }
 #endif
@@ -2790,7 +2791,8 @@
   return true;
 }
 
-// If Then makes up to four following instructions (the IT block) conditional.
+// If Then makes up to four following instructions (the IT block)
+// conditional.
 bool EmulateInstructionARM::EmulateIT(const uint32_t opcode,
                                       const ARMEncoding encoding) {
 #if 0
@@ -2833,7 +2835,8 @@
     int32_t imm32; // PC-relative offset
     switch (encoding) {
     case eEncodingT1:
-      // The 'cond' field is handled in EmulateInstructionARM::CurrentCond().
+      // The 'cond' field is handled in
+      // EmulateInstructionARM::CurrentCond().
       imm32 = llvm::SignExtend32<9>(Bits32(opcode, 7, 0) << 1);
       target = pc + imm32;
       context.SetISAAndImmediateSigned(eModeThumb, 4 + imm32);
@@ -2844,7 +2847,8 @@
       context.SetISAAndImmediateSigned(eModeThumb, 4 + imm32);
       break;
     case eEncodingT3:
-      // The 'cond' field is handled in EmulateInstructionARM::CurrentCond().
+      // The 'cond' field is handled in
+      // EmulateInstructionARM::CurrentCond().
       {
         if (Bits32(opcode, 25, 23) == 7)
           return false; // See Branches and miscellaneous control on page
@@ -2891,11 +2895,9 @@
   return true;
 }
 
-// Compare and Branch on Nonzero and Compare and Branch on Zero compare the
-// value in a register with
-// zero and conditionally branch forward a constant value.  They do not affect
-// the condition flags.
-// CBNZ, CBZ
+// Compare and Branch on Nonzero and Compare and Branch on Zero compare
+// the value in a register with zero and conditionally branch forward a
+// constant value.  They do not affect the condition flags. CBNZ, CBZ
 bool EmulateInstructionARM::EmulateCB(const uint32_t opcode,
                                       const ARMEncoding encoding) {
 #if 0
@@ -2938,18 +2940,16 @@
   return true;
 }
 
-// Table Branch Byte causes a PC-relative forward branch using a table of single
-// byte offsets.
-// A base register provides a pointer to the table, and a second register
-// supplies an index into the table.
-// The branch length is twice the value of the byte returned from the table.
+// Table Branch Byte causes a PC-relative forward branch using a table of
+// single byte offsets. A base register provides a pointer to the table,
+// and a second register supplies an index into the table. The branch
+// length is twice the value of the byte returned from the table.
 //
-// Table Branch Halfword causes a PC-relative forward branch using a table of
-// single halfword offsets.
-// A base register provides a pointer to the table, and a second register
-// supplies an index into the table.
-// The branch length is twice the value of the halfword returned from the table.
-// TBB, TBH
+// Table Branch Halfword causes a PC-relative forward branch using a table
+// of single halfword offsets. A base register provides a pointer to the
+// table, and a second register supplies an index into the table. The
+// branch length is twice the value of the halfword returned from the
+// table. TBB, TBH
 bool EmulateInstructionARM::EmulateTB(const uint32_t opcode,
                                       const ARMEncoding encoding) {
 #if 0
@@ -2984,8 +2984,8 @@
       return false;
     }
 
-    // Read the address of the table from the operand register Rn.
-    // The PC can be used, in which case the table immediately follows this
+    // Read the address of the table from the operand register Rn. The PC
+    // can be used, in which case the table immediately follows this
     // instruction.
     uint32_t base = ReadCoreReg(Rn, &success);
     if (!success)
@@ -3022,9 +3022,9 @@
   return true;
 }
 
-// This instruction adds an immediate value to a register value, and writes the
-// result to the destination register.
-// It can optionally update the condition flags based on the result.
+// This instruction adds an immediate value to a register value, and
+// writes the result to the destination register. It can optionally update
+// the condition flags based on the result.
 bool EmulateInstructionARM::EmulateADDImmThumb(const uint32_t opcode,
                                                const ARMEncoding encoding) {
 #if 0
@@ -3071,8 +3071,8 @@
       break;
 
     case eEncodingT3:
-      // if Rd == '1111' && S == '1' then SEE CMN (immediate);
-      // d = UInt(Rd); n = UInt(Rn); setflags = (S == '1'); imm32 =
+      // if Rd == '1111' && S == '1' then SEE CMN (immediate); d =
+      // UInt(Rd); n = UInt(Rn); setflags = (S == '1'); imm32 =
       // ThumbExpandImm(i:imm3:imm8);
       d = Bits32(opcode, 11, 8);
       n = Bits32(opcode, 19, 16);
@@ -3144,9 +3144,9 @@
   return true;
 }
 
-// This instruction adds an immediate value to a register value, and writes the
-// result to the destination
-// register.  It can optionally update the condition flags based on the result.
+// This instruction adds an immediate value to a register value, and
+// writes the result to the destination register.  It can optionally
+// update the condition flags based on the result.
 bool EmulateInstructionARM::EmulateADDImmARM(const uint32_t opcode,
                                              const ARMEncoding encoding) {
 #if 0
@@ -3209,10 +3209,9 @@
   return true;
 }
 
-// This instruction adds a register value and an optionally-shifted register
-// value, and writes the result
-// to the destination register. It can optionally update the condition flags
-// based on the result.
+// This instruction adds a register value and an optionally-shifted
+// register value, and writes the result to the destination register. It
+// can optionally update the condition flags based on the result.
 bool EmulateInstructionARM::EmulateADDReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -3300,8 +3299,9 @@
   return true;
 }
 
-// Compare Negative (immediate) adds a register value and an immediate value.
-// It updates the condition flags based on the result, and discards the result.
+// Compare Negative (immediate) adds a register value and an immediate
+// value. It updates the condition flags based on the result, and discards
+// the result.
 bool EmulateInstructionARM::EmulateCMNImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -3349,9 +3349,9 @@
   return true;
 }
 
-// Compare Negative (register) adds a register value and an optionally-shifted
-// register value.
-// It updates the condition flags based on the result, and discards the result.
+// Compare Negative (register) adds a register value and an optionally-
+// shifted register value. It updates the condition flags based on the
+// result, and discards the result.
 bool EmulateInstructionARM::EmulateCMNReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -3420,7 +3420,8 @@
 }
 
 // Compare (immediate) subtracts an immediate value from a register value.
-// It updates the condition flags based on the result, and discards the result.
+// It updates the condition flags based on the result, and discards the
+// result.
 bool EmulateInstructionARM::EmulateCMPImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -3472,9 +3473,9 @@
   return true;
 }
 
-// Compare (register) subtracts an optionally-shifted register value from a
-// register value.
-// It updates the condition flags based on the result, and discards the result.
+// Compare (register) subtracts an optionally-shifted register value from
+// a register value. It updates the condition flags based on the result,
+// and discards the result.
 bool EmulateInstructionARM::EmulateCMPReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -3552,10 +3553,9 @@
 }
 
 // Arithmetic Shift Right (immediate) shifts a register value right by an
-// immediate number of bits,
-// shifting in copies of its sign bit, and writes the result to the destination
-// register.  It can
-// optionally update the condition flags based on the result.
+// immediate number of bits, shifting in copies of its sign bit, and
+// writes the result to the destination register.  It can optionally
+// update the condition flags based on the result.
 bool EmulateInstructionARM::EmulateASRImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -3577,13 +3577,11 @@
   return EmulateShiftImm(opcode, encoding, SRType_ASR);
 }
 
-// Arithmetic Shift Right (register) shifts a register value right by a variable
-// number of bits,
-// shifting in copies of its sign bit, and writes the result to the destination
-// register.
-// The variable number of bits is read from the bottom byte of a register. It
-// can optionally update
-// the condition flags based on the result.
+// Arithmetic Shift Right (register) shifts a register value right by a
+// variable number of bits, shifting in copies of its sign bit, and writes
+// the result to the destination register. The variable number of bits is
+// read from the bottom byte of a register. It can optionally update the
+// condition flags based on the result.
 bool EmulateInstructionARM::EmulateASRReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -3603,11 +3601,10 @@
   return EmulateShiftReg(opcode, encoding, SRType_ASR);
 }
 
-// Logical Shift Left (immediate) shifts a register value left by an immediate
-// number of bits,
-// shifting in zeros, and writes the result to the destination register.  It can
-// optionally
-// update the condition flags based on the result.
+// Logical Shift Left (immediate) shifts a register value left by an
+// immediate number of bits, shifting in zeros, and writes the result to
+// the destination register.  It can optionally update the condition flags
+// based on the result.
 bool EmulateInstructionARM::EmulateLSLImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -3629,13 +3626,11 @@
   return EmulateShiftImm(opcode, encoding, SRType_LSL);
 }
 
-// Logical Shift Left (register) shifts a register value left by a variable
-// number of bits,
-// shifting in zeros, and writes the result to the destination register.  The
-// variable number
-// of bits is read from the bottom byte of a register. It can optionally update
-// the condition
-// flags based on the result.
+// Logical Shift Left (register) shifts a register value left by a
+// variable number of bits, shifting in zeros, and writes the result to
+// the destination register.  The variable number of bits is read from the
+// bottom byte of a register. It can optionally update the condition flags
+// based on the result.
 bool EmulateInstructionARM::EmulateLSLReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -3655,11 +3650,10 @@
   return EmulateShiftReg(opcode, encoding, SRType_LSL);
 }
 
-// Logical Shift Right (immediate) shifts a register value right by an immediate
-// number of bits,
-// shifting in zeros, and writes the result to the destination register.  It can
-// optionally
-// update the condition flags based on the result.
+// Logical Shift Right (immediate) shifts a register value right by an
+// immediate number of bits, shifting in zeros, and writes the result to
+// the destination register.  It can optionally update the condition flags
+// based on the result.
 bool EmulateInstructionARM::EmulateLSRImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -3681,13 +3675,11 @@
   return EmulateShiftImm(opcode, encoding, SRType_LSR);
 }
 
-// Logical Shift Right (register) shifts a register value right by a variable
-// number of bits,
-// shifting in zeros, and writes the result to the destination register.  The
-// variable number
-// of bits is read from the bottom byte of a register. It can optionally update
-// the condition
-// flags based on the result.
+// Logical Shift Right (register) shifts a register value right by a
+// variable number of bits, shifting in zeros, and writes the result to
+// the destination register.  The variable number of bits is read from the
+// bottom byte of a register. It can optionally update the condition flags
+// based on the result.
 bool EmulateInstructionARM::EmulateLSRReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -3707,11 +3699,10 @@
   return EmulateShiftReg(opcode, encoding, SRType_LSR);
 }
 
-// Rotate Right (immediate) provides the value of the contents of a register
-// rotated by a constant value.
-// The bits that are rotated off the right end are inserted into the vacated bit
-// positions on the left.
-// It can optionally update the condition flags based on the result.
+// Rotate Right (immediate) provides the value of the contents of a
+// register rotated by a constant value. The bits that are rotated off the
+// right end are inserted into the vacated bit positions on the left. It
+// can optionally update the condition flags based on the result.
 bool EmulateInstructionARM::EmulateRORImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -3733,13 +3724,12 @@
   return EmulateShiftImm(opcode, encoding, SRType_ROR);
 }
 
-// Rotate Right (register) provides the value of the contents of a register
-// rotated by a variable number of bits.
-// The bits that are rotated off the right end are inserted into the vacated bit
-// positions on the left.
-// The variable number of bits is read from the bottom byte of a register. It
-// can optionally update the condition
-// flags based on the result.
+// Rotate Right (register) provides the value of the contents of a
+// register rotated by a variable number of bits. The bits that are
+// rotated off the right end are inserted into the vacated bit positions
+// on the left. The variable number of bits is read from the bottom byte
+// of a register. It can optionally update the condition flags based on
+// the result.
 bool EmulateInstructionARM::EmulateRORReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -3759,12 +3749,12 @@
   return EmulateShiftReg(opcode, encoding, SRType_ROR);
 }
 
-// Rotate Right with Extend provides the value of the contents of a register
-// shifted right by one place,
-// with the carry flag shifted into bit [31].
+// Rotate Right with Extend provides the value of the contents of a
+// register shifted right by one place, with the carry flag shifted into
+// bit [31].
 //
-// RRX can optionally update the condition flags based on the result.
-// In that case, bit [0] is shifted into the carry flag.
+// RRX can optionally update the condition flags based on the result. In
+// that case, bit [0] is shifted into the carry flag.
 bool EmulateInstructionARM::EmulateRRX(const uint32_t opcode,
                                        const ARMEncoding encoding) {
 #if 0
@@ -3808,10 +3798,9 @@
     // A8.6.139 ROR (immediate) -- Encoding T1
     ARMEncoding use_encoding = encoding;
     if (shift_type == SRType_ROR && use_encoding == eEncodingT1) {
-      // Morph the T1 encoding from the ARM Architecture Manual into T2 encoding
-      // to
-      // have the same decoding of bit fields as the other Thumb2 shift
-      // operations.
+      // Morph the T1 encoding from the ARM Architecture Manual into T2
+      // encoding to have the same decoding of bit fields as the other
+      // Thumb2 shift operations.
       use_encoding = eEncodingT2;
     }
 
@@ -3948,10 +3937,9 @@
   return true;
 }
 
-// LDM loads multiple registers from consecutive memory locations, using an
-// address from a base register.  Optionally the address just above the highest
-// of those locations
-// can be written back to the base register.
+// LDM loads multiple registers from consecutive memory locations, using
+// an address from a base register.  Optionally the address just above the
+// highest of those locations can be written back to the base register.
 bool EmulateInstructionARM::EmulateLDM(const uint32_t opcode,
                                        const ARMEncoding encoding) {
 #if 0
@@ -3990,15 +3978,15 @@
         return false;
       break;
     case eEncodingT2:
-      // if W == '1' && Rn == '1101' then SEE POP;
-      // n = UInt(Rn); registers = P:M:'0':register_list; wback = (W == '1');
+      // if W == '1' && Rn == '1101' then SEE POP; n = UInt(Rn); registers
+      // = P:M:'0':register_list; wback = (W == '1');
       n = Bits32(opcode, 19, 16);
       registers = Bits32(opcode, 15, 0);
       registers = registers & 0xdfff; // Make sure bit 13 is zero.
       wback = BitIsSet(opcode, 21);
 
-      // if n == 15 || BitCount(registers) < 2 || (P == '1' && M == '1') then
-      // UNPREDICTABLE;
+      // if n == 15 || BitCount(registers) < 2 || (P == '1' && M == '1')
+      // then UNPREDICTABLE;
       if ((n == 15) || (BitCount(registers) < 2) ||
           (BitIsSet(opcode, 14) && BitIsSet(opcode, 15)))
         return false;
@@ -4090,11 +4078,10 @@
   return true;
 }
 
-// LDMDA loads multiple registers from consecutive memory locations using an
-// address from a base register.
-// The consecutive memory locations end at this address and the address just
-// below the lowest of those locations
-// can optionally be written back to the base register.
+// LDMDA loads multiple registers from consecutive memory locations using
+// an address from a base register. The consecutive memory locations end
+// at this address and the address just below the lowest of those
+// locations can optionally be written back to the base register.
 bool EmulateInstructionARM::EmulateLDMDA(const uint32_t opcode,
                                          const ARMEncoding encoding) {
 #if 0
@@ -4186,7 +4173,8 @@
         return false;
     }
 
-    // if wback && registers<n> == '0' then R[n] = R[n] - 4*BitCount(registers);
+    // if wback && registers<n> == '0' then R[n] = R[n] -
+    // 4*BitCount(registers);
     if (wback && BitIsClear(registers, n)) {
       if (!success)
         return false;
@@ -4207,11 +4195,10 @@
   return true;
 }
 
-// LDMDB loads multiple registers from consecutive memory locations using an
-// address from a base register.  The
-// consecutive memory locations end just below this address, and the address of
-// the lowest of those locations can
-// be optionally written back to the base register.
+// LDMDB loads multiple registers from consecutive memory locations using
+// an address from a base register.  The consecutive memory locations end
+// just below this address, and the address of the lowest of those
+// locations can be optionally written back to the base register.
 bool EmulateInstructionARM::EmulateLDMDB(const uint32_t opcode,
                                          const ARMEncoding encoding) {
 #if 0
@@ -4239,14 +4226,15 @@
     const uint32_t addr_byte_size = GetAddressByteSize();
     switch (encoding) {
     case eEncodingT1:
-      // n = UInt(Rn); registers = P:M:'0':register_list; wback = (W == '1');
+      // n = UInt(Rn); registers = P:M:'0':register_list; wback = (W ==
+      // '1');
       n = Bits32(opcode, 19, 16);
       registers = Bits32(opcode, 15, 0);
       registers = registers & 0xdfff; // Make sure bit 13 is a zero.
       wback = BitIsSet(opcode, 21);
 
-      // if n == 15 || BitCount(registers) < 2 || (P == '1' && M == '1') then
-      // UNPREDICTABLE;
+      // if n == 15 || BitCount(registers) < 2 || (P == '1' && M == '1')
+      // then UNPREDICTABLE;
       if ((n == 15) || (BitCount(registers) < 2) ||
           (BitIsSet(opcode, 14) && BitIsSet(opcode, 15)))
         return false;
@@ -4324,7 +4312,8 @@
         return false;
     }
 
-    // if wback && registers<n> == '0' then R[n] = R[n] - 4*BitCount(registers);
+    // if wback && registers<n> == '0' then R[n] = R[n] -
+    // 4*BitCount(registers);
     if (wback && BitIsClear(registers, n)) {
       if (!success)
         return false;
@@ -4338,19 +4327,18 @@
         return false;
     }
 
-    // if wback && registers<n> == '1' then R[n] = bits(32) UNKNOWN; // Only
-    // possible for encoding A1
+    // if wback && registers<n> == '1' then R[n] = bits(32) UNKNOWN; //
+    // Only possible for encoding A1
     if (wback && BitIsSet(registers, n))
       return WriteBits32Unknown(n);
   }
   return true;
 }
 
-// LDMIB loads multiple registers from consecutive memory locations using an
-// address from a base register.  The
-// consecutive memory locations start just above this address, and thea ddress
-// of the last of those locations can
-// optinoally be written back to the base register.
+// LDMIB loads multiple registers from consecutive memory locations using
+// an address from a base register.  The consecutive memory locations
+// start just above this address, and thea ddress of the last of those
+// locations can optinoally be written back to the base register.
 bool EmulateInstructionARM::EmulateLDMIB(const uint32_t opcode,
                                          const ARMEncoding encoding) {
 #if 0
@@ -4438,7 +4426,8 @@
         return false;
     }
 
-    // if wback && registers<n> == '0' then R[n] = R[n] + 4*BitCount(registers);
+    // if wback && registers<n> == '0' then R[n] = R[n] +
+    // 4*BitCount(registers);
     if (wback && BitIsClear(registers, n)) {
       if (!success)
         return false;
@@ -4452,18 +4441,17 @@
         return false;
     }
 
-    // if wback && registers<n> == '1' then R[n] = bits(32) UNKNOWN; // Only
-    // possible for encoding A1
+    // if wback && registers<n> == '1' then R[n] = bits(32) UNKNOWN; //
+    // Only possible for encoding A1
     if (wback && BitIsSet(registers, n))
       return WriteBits32Unknown(n);
   }
   return true;
 }
 
-// Load Register (immediate) calculates an address from a base register value
-// and
-// an immediate offset, loads a word from memory, and writes to a register.
-// LDR (immediate, Thumb)
+// Load Register (immediate) calculates an address from a base register
+// value and an immediate offset, loads a word from memory, and writes to
+// a register. LDR (immediate, Thumb)
 bool EmulateInstructionARM::EmulateLDRRtRnImm(const uint32_t opcode,
                                               const ARMEncoding encoding) {
 #if 0
@@ -4538,10 +4526,9 @@
 
     case eEncodingT4:
       // if Rn == '1111' then SEE LDR (literal);
-      // if P == '1' && U == '1' && W == '0' then SEE LDRT;
-      // if Rn == '1101' && P == '0' && U == '1' && W == '1' && imm8 ==
-      // '00000100' then SEE POP;
-      // if P == '0' && W == '0' then UNDEFINED;
+      // if P == '1' && U == '1' && W == '0' then SEE LDRT; if Rn ==
+      // '1101' && P == '0' && U == '1' && W == '1' && imm8 == '00000100'
+      // then SEE POP; if P == '0' && W == '0' then UNDEFINED;
       if (BitIsClear(opcode, 10) && BitIsClear(opcode, 8))
         return false;
 
@@ -4555,8 +4542,8 @@
       add = BitIsSet(opcode, 9);
       wback = BitIsSet(opcode, 8);
 
-      // if (wback && n == t) || (t == 15 && InITBlock() && !LastInITBlock())
-      // then UNPREDICTABLE;
+      // if (wback && n == t) || (t == 15 && InITBlock() &&
+      // !LastInITBlock()) then UNPREDICTABLE;
       if ((wback && (Rn == Rt)) ||
           ((Rt == 15) && InITBlock() && !LastInITBlock()))
         return false;
@@ -4622,11 +4609,11 @@
   return true;
 }
 
-// STM (Store Multiple Increment After) stores multiple registers to consecutive
-// memory locations using an address
-// from a base register.  The consecutive memory locations start at this
-// address, and the address just above the last
-// of those locations can optionally be written back to the base register.
+// STM (Store Multiple Increment After) stores multiple registers to
+// consecutive memory locations using an address from a base register.
+// The consecutive memory locations start at this address, and the address
+// just above the last of those locations can optionally be written back
+// to the base register.
 bool EmulateInstructionARM::EmulateSTM(const uint32_t opcode,
                                        const ARMEncoding encoding) {
 #if 0
@@ -4671,7 +4658,8 @@
       break;
 
     case eEncodingT2:
-      // n = UInt(Rn); registers = '0':M:'0':register_list; wback = (W == '1');
+      // n = UInt(Rn); registers = '0':M:'0':register_list; wback = (W ==
+      // '1');
       n = Bits32(opcode, 19, 16);
       registers = Bits32(opcode, 15, 0);
       registers = registers & 0x5fff; // Make sure bits 15 & 13 are zeros.
@@ -4724,8 +4712,8 @@
           lowest_set_bit = i;
         // if i == n && wback && i != LowestSetBit(registers) then
         if ((i == n) && wback && (i != lowest_set_bit))
-          // MemA[address,4] = bits(32) UNKNOWN; // Only possible for encodings
-          // T1 and A1
+          // MemA[address,4] = bits(32) UNKNOWN; // Only possible for
+          // encodings T1 and A1
           WriteBits32UnknownToMemory(address + offset);
         else {
           // MemA[address,4] = R[i];
@@ -4775,10 +4763,10 @@
 }
 
 // STMDA (Store Multiple Decrement After) stores multiple registers to
-// consecutive memory locations using an address
-// from a base register.  The consecutive memory locations end at this address,
-// and the address just below the lowest
-// of those locations can optionally be written back to the base register.
+// consecutive memory locations using an address from a base register.
+// The consecutive memory locations end at this address, and the address
+// just below the lowest of those locations can optionally be written back
+// to the base register.
 bool EmulateInstructionARM::EmulateSTMDA(const uint32_t opcode,
                                          const ARMEncoding encoding) {
 #if 0
@@ -4897,10 +4885,10 @@
 }
 
 // STMDB (Store Multiple Decrement Before) stores multiple registers to
-// consecutive memory locations using an address
-// from a base register.  The consecutive memory locations end just below this
-// address, and the address of the first of
-// those locations can optionally be written back to the base register.
+// consecutive memory locations using an address from a base register.
+// The consecutive memory locations end just below this address, and the
+// address of the first of those locations can optionally be written back
+// to the base register.
 bool EmulateInstructionARM::EmulateSTMDB(const uint32_t opcode,
                                          const ARMEncoding encoding) {
 #if 0
@@ -4937,7 +4925,8 @@
       if ((BitIsSet(opcode, 21)) && (Bits32(opcode, 19, 16) == 13)) {
         // See PUSH
       }
-      // n = UInt(Rn); registers = '0':M:'0':register_list; wback = (W == '1');
+      // n = UInt(Rn); registers = '0':M:'0':register_list; wback = (W ==
+      // '1');
       n = Bits32(opcode, 19, 16);
       registers = Bits32(opcode, 15, 0);
       registers = registers & 0x5fff; // Make sure bits 15 & 13 are zeros.
@@ -4951,8 +4940,8 @@
       break;
 
     case eEncodingA1:
-      // if W == '1' && Rn == '1101' && BitCount(register_list) >= 2 then SEE
-      // PUSH;
+      // if W == '1' && Rn == '1101' && BitCount(register_list) >= 2 then
+      // SEE PUSH;
       if (BitIsSet(opcode, 21) && (Bits32(opcode, 19, 16) == 13) &&
           BitCount(Bits32(opcode, 15, 0)) >= 2) {
         // See Push
@@ -4994,8 +4983,8 @@
           lowest_set_bit = i;
         // if i == n && wback && i != LowestSetBit(registers) then
         if ((i == n) && wback && (i != lowest_set_bit))
-          // MemA[address,4] = bits(32) UNKNOWN; // Only possible for encoding
-          // A1
+          // MemA[address,4] = bits(32) UNKNOWN; // Only possible for
+          // encoding A1
           WriteBits32UnknownToMemory(address + offset);
         else {
           // MemA[address,4] = R[i];
@@ -5046,10 +5035,10 @@
 }
 
 // STMIB (Store Multiple Increment Before) stores multiple registers to
-// consecutive memory locations using an address
-// from a base register.  The consecutive memory locations start just above this
-// address, and the address of the last
-// of those locations can optionally be written back to the base register.
+// consecutive memory locations using an address from a base register.
+// The consecutive memory locations start just above this address, and the
+// address of the last of those locations can optionally be written back
+// to the base register.
 bool EmulateInstructionARM::EmulateSTMIB(const uint32_t opcode,
                                          const ARMEncoding encoding) {
 #if 0
@@ -5168,10 +5157,9 @@
   return true;
 }
 
-// STR (store immediate) calculates an address from a base register value and an
-// immediate offset, and stores a word
-// from a register to memory.  It can use offset, post-indexed, or pre-indexed
-// addressing.
+// STR (store immediate) calculates an address from a base register value
+// and an immediate offset, and stores a word from a register to memory.
+// It can use offset, post-indexed, or pre-indexed addressing.
 bool EmulateInstructionARM::EmulateSTRThumb(const uint32_t opcode,
                                             const ARMEncoding encoding) {
 #if 0
@@ -5244,10 +5232,10 @@
       break;
 
     case eEncodingT4:
-      // if P == '1' && U == '1' && W == '0' then SEE STRT;
-      // if Rn == '1101' && P == '1' && U == '0' && W == '1' && imm8 ==
-      // '00000100' then SEE PUSH;
-      // if Rn == '1111' || (P == '0' && W == '0') then UNDEFINED;
+      // if P == '1' && U == '1' && W == '0' then SEE STRT; if Rn ==
+      // '1101' && P == '1' && U == '0' && W == '1' && imm8 == '00000100'
+      // then SEE PUSH; if Rn == '1111' || (P == '0' && W == '0') then
+      // UNDEFINED;
       if ((Bits32(opcode, 19, 16) == 15) ||
           (BitIsClear(opcode, 10) && BitIsClear(opcode, 8)))
         return false;
@@ -5335,10 +5323,9 @@
   return true;
 }
 
-// STR (Store Register) calculates an address from a base register value and an
-// offset register value, stores a
-// word from a register to memory.   The offset register value can optionally be
-// shifted.
+// STR (Store Register) calculates an address from a base register value
+// and an offset register value, stores a word from a register to memory.
+// The offset register value can optionally be shifted.
 bool EmulateInstructionARM::EmulateSTRRegister(const uint32_t opcode,
                                                const ARMEncoding encoding) {
 #if 0
@@ -5375,9 +5362,8 @@
     // EncodingSpecificOperations (); NullCheckIfThumbEE(n);
     switch (encoding) {
     case eEncodingT1:
-      // if CurrentInstrSet() == InstrSet_ThumbEE then SEE "Modified operation
-      // in ThumbEE";
-      // t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
+      // if CurrentInstrSet() == InstrSet_ThumbEE then SEE "Modified
+      // operation in ThumbEE"; t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
       t = Bits32(opcode, 2, 0);
       n = Bits32(opcode, 5, 3);
       m = Bits32(opcode, 8, 6);
@@ -5423,8 +5409,8 @@
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
 
-      // index = (P == '1');	add = (U == '1');	wback = (P == '0') ||
-      // (W == '1');
+      // index = (P == '1');     add = (U == '1');       wback = (P ==
+      // '0') || (W == '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = (BitIsClear(opcode, 24) || BitIsSet(opcode, 21));
@@ -5495,8 +5481,8 @@
     EmulateInstruction::Context context;
     context.type = eContextRegisterStore;
 
-    // if UnalignedSupport() || address<1:0> == '00' || CurrentInstrSet() ==
-    // InstrSet_ARM then
+    // if UnalignedSupport() || address<1:0> == '00' || CurrentInstrSet()
+    // == InstrSet_ARM then
     if (UnalignedSupport() ||
         (BitIsClear(address, 1) && BitIsClear(address, 0)) ||
         CurrentInstrSet() == eModeARM) {
@@ -5584,8 +5570,8 @@
       break;
 
     case eEncodingT3:
-      // if P == '1' && U == '1' && W == '0' then SEE STRBT;
-      // if Rn == '1111' || (P == '0' && W == '0') then UNDEFINED;
+      // if P == '1' && U == '1' && W == '0' then SEE STRBT; if Rn ==
+      // '1111' || (P == '0' && W == '0') then UNDEFINED;
       if (Bits32(opcode, 19, 16) == 15)
         return false;
 
@@ -5663,9 +5649,8 @@
 }
 
 // STRH (register) calculates an address from a base register value and an
-// offset register value, and stores a
-// halfword from a register to memory.  The offset register value can be shifted
-// left by 0, 1, 2, or 3 bits.
+// offset register value, and stores a halfword from a register to memory.
+// The offset register value can be shifted left by 0, 1, 2, or 3 bits.
 bool EmulateInstructionARM::EmulateSTRHRegister(const uint32_t opcode,
                                                 const ARMEncoding encoding) {
 #if 0
@@ -5696,9 +5681,8 @@
     // EncodingSpecificOperations(); NullCheckIfThumbEE(n);
     switch (encoding) {
     case eEncodingT1:
-      // if CurrentInstrSet() == InstrSet_ThumbEE then SEE "Modified operation
-      // in ThumbEE";
-      // t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
+      // if CurrentInstrSet() == InstrSet_ThumbEE then SEE "Modified
+      // operation in ThumbEE"; t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
       t = Bits32(opcode, 2, 0);
       n = Bits32(opcode, 5, 3);
       m = Bits32(opcode, 8, 6);
@@ -5745,8 +5729,8 @@
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
 
-      // index = (P == '1');	add = (U == '1');	wback = (P == '0') ||
-      // (W == '1');
+      // index = (P == '1');     add = (U == '1');       wback = (P ==
+      // '0') || (W == '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = (BitIsClear(opcode, 24) || BitIsSet(opcode, 21));
@@ -5841,11 +5825,10 @@
   return true;
 }
 
-// Add with Carry (immediate) adds an immediate value and the carry flag value
-// to a register value,
-// and writes the result to the destination register.  It can optionally update
-// the condition flags
-// based on the result.
+// Add with Carry (immediate) adds an immediate value and the carry flag
+// value to a register value, and writes the result to the destination
+// register.  It can optionally update the condition flags based on the
+// result.
 bool EmulateInstructionARM::EmulateADCImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -5911,11 +5894,10 @@
   return true;
 }
 
-// Add with Carry (register) adds a register value, the carry flag value, and an
-// optionally-shifted
-// register value, and writes the result to the destination register.  It can
-// optionally update the
-// condition flags based on the result.
+// Add with Carry (register) adds a register value, the carry flag value,
+// and an optionally-shifted register value, and writes the result to the
+// destination register.  It can optionally update the condition flags
+// based on the result.
 bool EmulateInstructionARM::EmulateADCReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -5999,9 +5981,8 @@
   return true;
 }
 
-// This instruction adds an immediate value to the PC value to form a
-// PC-relative address,
-// and writes the result to the destination register.
+// This instruction adds an immediate value to the PC value to form a PC-
+// relative address, and writes the result to the destination register.
 bool EmulateInstructionARM::EmulateADR(const uint32_t opcode,
                                        const ARMEncoding encoding) {
 #if 0
@@ -6062,10 +6043,9 @@
   return true;
 }
 
-// This instruction performs a bitwise AND of a register value and an immediate
-// value, and writes the result
-// to the destination register.  It can optionally update the condition flags
-// based on the result.
+// This instruction performs a bitwise AND of a register value and an
+// immediate value, and writes the result to the destination register.  It
+// can optionally update the condition flags based on the result.
 bool EmulateInstructionARM::EmulateANDImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -6139,9 +6119,8 @@
 }
 
 // This instruction performs a bitwise AND of a register value and an
-// optionally-shifted register value,
-// and writes the result to the destination register.  It can optionally update
-// the condition flags
+// optionally-shifted register value, and writes the result to the
+// destination register.  It can optionally update the condition flags
 // based on the result.
 bool EmulateInstructionARM::EmulateANDReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
@@ -6229,11 +6208,10 @@
   return true;
 }
 
-// Bitwise Bit Clear (immediate) performs a bitwise AND of a register value and
-// the complement of an
-// immediate value, and writes the result to the destination register.  It can
-// optionally update the
-// condition flags based on the result.
+// Bitwise Bit Clear (immediate) performs a bitwise AND of a register
+// value and the complement of an immediate value, and writes the result
+// to the destination register.  It can optionally update the condition
+// flags based on the result.
 bool EmulateInstructionARM::EmulateBICImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -6305,11 +6283,10 @@
   return true;
 }
 
-// Bitwise Bit Clear (register) performs a bitwise AND of a register value and
-// the complement of an
-// optionally-shifted register value, and writes the result to the destination
-// register.
-// It can optionally update the condition flags based on the result.
+// Bitwise Bit Clear (register) performs a bitwise AND of a register value
+// and the complement of an optionally-shifted register value, and writes
+// the result to the destination register. It can optionally update the
+// condition flags based on the result.
 bool EmulateInstructionARM::EmulateBICReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -6395,10 +6372,9 @@
   return true;
 }
 
-// LDR (immediate, ARM) calculates an address from a base register value and an
-// immediate offset, loads a word
-// from memory, and writes it to a register.  It can use offset, post-indexed,
-// or pre-indexed addressing.
+// LDR (immediate, ARM) calculates an address from a base register value
+// and an immediate offset, loads a word from memory, and writes it to a
+// register.  It can use offset, post-indexed, or pre-indexed addressing.
 bool EmulateInstructionARM::EmulateLDRImmediateARM(const uint32_t opcode,
                                                    const ARMEncoding encoding) {
 #if 0
@@ -6433,14 +6409,14 @@
       // if Rn == '1111' then SEE LDR (literal);
       // if P == '0' && W == '1' then SEE LDRT;
       // if Rn == '1101' && P == '0' && U == '1' && W == '0' && imm12 ==
-      // '000000000100' then SEE POP;
-      // t == UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
+      // '000000000100' then SEE POP; t == UInt(Rt); n = UInt(Rn); imm32 =
+      // ZeroExtend(imm12, 32);
       t = Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
       imm32 = Bits32(opcode, 11, 0);
 
-      // index = (P == '1');	add = (U == '1');	wback = (P == '0') ||
-      // (W == '1');
+      // index = (P == '1');     add = (U == '1');       wback = (P ==
+      // '0') || (W == '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = (BitIsClear(opcode, 24) || BitIsSet(opcode, 21));
@@ -6497,7 +6473,8 @@
 
     // if t == 15 then
     if (t == 15) {
-      // if address<1:0> == '00' then LoadWritePC(data); else UNPREDICTABLE;
+      // if address<1:0> == '00' then LoadWritePC(data); else
+      // UNPREDICTABLE;
       if (BitIsClear(address, 1) && BitIsClear(address, 0)) {
         // LoadWritePC (data);
         context.type = eContextRegisterLoad;
@@ -6532,10 +6509,9 @@
   return true;
 }
 
-// LDR (register) calculates an address from a base register value and an offset
-// register value, loads a word
-// from memory, and writes it to a register.  The offset register value can
-// optionally be shifted.
+// LDR (register) calculates an address from a base register value and an
+// offset register value, loads a word from memory, and writes it to a
+// register.  The offset register value can optionally be shifted.
 bool EmulateInstructionARM::EmulateLDRRegister(const uint32_t opcode,
                                                const ARMEncoding encoding) {
 #if 0
@@ -6573,9 +6549,8 @@
 
     switch (encoding) {
     case eEncodingT1:
-      // if CurrentInstrSet() == InstrSet_ThumbEE then SEE "Modified operation
-      // in ThumbEE";
-      // t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
+      // if CurrentInstrSet() == InstrSet_ThumbEE then SEE "Modified
+      // operation in ThumbEE"; t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
       t = Bits32(opcode, 2, 0);
       n = Bits32(opcode, 5, 3);
       m = Bits32(opcode, 8, 6);
@@ -6624,8 +6599,8 @@
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
 
-      // index = (P == '1');	add = (U == '1');	wback = (P == '0') ||
-      // (W == '1');
+      // index = (P == '1');     add = (U == '1');       wback = (P ==
+      // '0') || (W == '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = (BitIsClear(opcode, 24) || BitIsSet(opcode, 21));
@@ -6661,8 +6636,8 @@
     addr_t offset_addr;
     addr_t address;
 
-    // offset = Shift(R[m], shift_t, shift_n, APSR.C);   -- Note "The APSR is an
-    // application level alias for the CPSR".
+    // offset = Shift(R[m], shift_t, shift_n, APSR.C);   -- Note "The APSR
+    // is an application level alias for the CPSR".
     addr_t offset =
         Shift(Rm, shift_t, shift_n, Bit32(m_opcode_cpsr, APSR_C), &success);
     if (!success)
@@ -6703,7 +6678,8 @@
 
     // if t == 15 then
     if (t == 15) {
-      // if address<1:0> == '00' then LoadWritePC(data); else UNPREDICTABLE;
+      // if address<1:0> == '00' then LoadWritePC(data); else
+      // UNPREDICTABLE;
       if (BitIsClear(address, 1) && BitIsClear(address, 0)) {
         context.type = eContextRegisterLoad;
         context.SetRegisterPlusOffset(base_reg, address - Rn);
@@ -6805,8 +6781,8 @@
       break;
 
     case eEncodingT3:
-      // if P == '1' && U == '1' && W == '0' then SEE LDRBT;
-      // if P == '0' && W == '0' then UNDEFINED;
+      // if P == '1' && U == '1' && W == '0' then SEE LDRBT; if P == '0'
+      // && W == '0' then UNDEFINED;
       if (BitIsClear(opcode, 10) && BitIsClear(opcode, 8))
         return false;
 
@@ -6888,8 +6864,8 @@
 }
 
 // LDRB (literal) calculates an address from the PC value and an immediate
-// offset, loads a byte from memory,
-// zero-extends it to form a 32-bit word and writes it to a register.
+// offset, loads a byte from memory, zero-extends it to form a 32-bit word
+// and writes it to a register.
 bool EmulateInstructionARM::EmulateLDRBLiteral(const uint32_t opcode,
                                                const ARMEncoding encoding) {
 #if 0
@@ -6968,10 +6944,9 @@
 }
 
 // LDRB (register) calculates an address from a base register value and an
-// offset rigister value, loads a byte from
-// memory, zero-extends it to form a 32-bit word, and writes it to a register.
-// The offset register value can
-// optionally be shifted.
+// offset rigister value, loads a byte from memory, zero-extends it to
+// form a 32-bit word, and writes it to a register. The offset register
+// value can optionally be shifted.
 bool EmulateInstructionARM::EmulateLDRBRegister(const uint32_t opcode,
                                                 const ARMEncoding encoding) {
 #if 0
@@ -7049,8 +7024,8 @@
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
 
-      // index = (P == '1');	add = (U == '1');	wback = (P == '0') ||
-      // (W == '1');
+      // index = (P == '1');     add = (U == '1');       wback = (P ==
+      // '0') || (W == '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = (BitIsClear(opcode, 24) || BitIsSet(opcode, 21));
@@ -7130,11 +7105,10 @@
   return true;
 }
 
-// LDRH (immediate, Thumb) calculates an address from a base register value and
-// an immediate offset, loads a
-// halfword from memory, zero-extends it to form a 32-bit word, and writes it to
-// a register.  It can use offset,
-// post-indexed, or pre-indexed addressing.
+// LDRH (immediate, Thumb) calculates an address from a base register
+// value and an immediate offset, loads a halfword from memory, zero-
+// extends it to form a 32-bit word, and writes it to a register.  It can
+// use offset, post-indexed, or pre-indexed addressing.
 bool EmulateInstructionARM::EmulateLDRHImmediate(const uint32_t opcode,
                                                  const ARMEncoding encoding) {
 #if 0
@@ -7176,9 +7150,9 @@
       break;
 
     case eEncodingT2:
-      // if Rt == '1111' then SEE "Unallocated memory hints";
-      // if Rn == '1111' then SEE LDRH (literal);
-      // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
+      // if Rt == '1111' then SEE "Unallocated memory hints"; if Rn ==
+      // '1111' then SEE LDRH (literal); t = UInt(Rt); n = UInt(Rn); imm32
+      // = ZeroExtend(imm12, 32);
       t = Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
       imm32 = Bits32(opcode, 11, 0);
@@ -7194,11 +7168,10 @@
       break;
 
     case eEncodingT3:
-      // if Rn == '1111' then SEE LDRH (literal);
-      // if Rt == '1111' && P == '1' && U == '0' && W == '0' then SEE
-      // "Unallocated memory hints";
-      // if P == '1' && U == '1' && W == '0' then SEE LDRHT;
-      // if P == '0' && W == '0' then UNDEFINED;
+      // if Rn == '1111' then SEE LDRH (literal); if Rt == '1111' && P ==
+      // '1' && U == '0' && W == '0' then SEE "Unallocated memory hints";
+      // if P == '1' && U == '1' && W == '0' then SEE LDRHT; if P == '0'
+      // && W == '0' then UNDEFINED;
       if (BitIsClear(opcode, 10) && BitIsClear(opcode, 8))
         return false;
 
@@ -7280,8 +7253,8 @@
 }
 
 // LDRH (literal) caculates an address from the PC value and an immediate
-// offset, loads a halfword from memory,
-// zero-extends it to form a 32-bit word, and writes it to a register.
+// offset, loads a halfword from memory, zero-extends it to form a 32-bit
+// word, and writes it to a register.
 bool EmulateInstructionARM::EmulateLDRHLiteral(const uint32_t opcode,
                                                const ARMEncoding encoding) {
 #if 0
@@ -7306,8 +7279,8 @@
     // EncodingSpecificOperations(); NullCheckIfThumbEE(15);
     switch (encoding) {
     case eEncodingT1:
-      // if Rt == '1111' then SEE "Unallocated memory hints";
-      // t = UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
+      // if Rt == '1111' then SEE "Unallocated memory hints"; t =
+      // UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
       t = Bits32(opcode, 15, 12);
       imm32 = Bits32(opcode, 11, 0);
       add = BitIsSet(opcode, 23);
@@ -7322,7 +7295,8 @@
       uint32_t imm4H = Bits32(opcode, 11, 8);
       uint32_t imm4L = Bits32(opcode, 3, 0);
 
-      // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U == '1');
+      // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U ==
+      // '1');
       t = Bits32(opcode, 15, 12);
       imm32 = (imm4H << 4) | imm4L;
       add = BitIsSet(opcode, 23);
@@ -7381,11 +7355,10 @@
   return true;
 }
 
-// LDRH (literal) calculates an address from a base register value and an offset
-// register value, loads a halfword
-// from memory, zero-extends it to form a 32-bit word, and writes it to a
-// register.  The offset register value can
-// be shifted left by 0, 1, 2, or 3 bits.
+// LDRH (literal) calculates an address from a base register value and an
+// offset register value, loads a halfword from memory, zero-extends it to
+// form a 32-bit word, and writes it to a register.  The offset register
+// value can be shifted left by 0, 1, 2, or 3 bits.
 bool EmulateInstructionARM::EmulateLDRHRegister(const uint32_t opcode,
                                                 const ARMEncoding encoding) {
 #if 0
@@ -7417,9 +7390,8 @@
     // EncodingSpecificOperations(); NullCheckIfThumbEE(n);
     switch (encoding) {
     case eEncodingT1:
-      // if CurrentInstrSet() == InstrSet_ThumbEE then SEE "Modified operation
-      // in ThumbEE";
-      // t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
+      // if CurrentInstrSet() == InstrSet_ThumbEE then SEE "Modified
+      // operation in ThumbEE"; t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
       t = Bits32(opcode, 2, 0);
       n = Bits32(opcode, 5, 3);
       m = Bits32(opcode, 8, 6);
@@ -7436,9 +7408,9 @@
       break;
 
     case eEncodingT2:
-      // if Rn == '1111' then SEE LDRH (literal);
-      // if Rt == '1111' then SEE "Unallocated memory hints";
-      // t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
+      // if Rn == '1111' then SEE LDRH (literal); if Rt == '1111' then SEE
+      // "Unallocated memory hints"; t = UInt(Rt); n = UInt(Rn); m =
+      // UInt(Rm);
       t = Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
@@ -7464,8 +7436,8 @@
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
 
-      // index = (P == '1');	add = (U == '1');	wback = (P == '0') ||
-      // (W == '1');
+      // index = (P == '1');     add = (U == '1');       wback = (P ==
+      // '0') || (W == '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = (BitIsClear(opcode, 24) || BitIsSet(opcode, 21));
@@ -7558,11 +7530,10 @@
   return true;
 }
 
-// LDRSB (immediate) calculates an address from a base register value and an
-// immediate offset, loads a byte from
-// memory, sign-extends it to form a 32-bit word, and writes it to a register.
-// It can use offset, post-indexed,
-// or pre-indexed addressing.
+// LDRSB (immediate) calculates an address from a base register value and
+// an immediate offset, loads a byte from memory, sign-extends it to form
+// a 32-bit word, and writes it to a register. It can use offset, post-
+// indexed, or pre-indexed addressing.
 bool EmulateInstructionARM::EmulateLDRSBImmediate(const uint32_t opcode,
                                                   const ARMEncoding encoding) {
 #if 0
@@ -7588,8 +7559,8 @@
     switch (encoding) {
     case eEncodingT1:
       // if Rt == '1111' then SEE PLI;
-      // if Rn == '1111' then SEE LDRSB (literal);
-      // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
+      // if Rn == '1111' then SEE LDRSB (literal); t = UInt(Rt); n =
+      // UInt(Rn); imm32 = ZeroExtend(imm12, 32);
       t = Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
       imm32 = Bits32(opcode, 11, 0);
@@ -7607,9 +7578,9 @@
 
     case eEncodingT2:
       // if Rt == '1111' && P == '1' && U == '0' && W == '0' then SEE PLI;
-      // if Rn == '1111' then SEE LDRSB (literal);
-      // if P == '1' && U == '1' && W == '0' then SEE LDRSBT;
-      // if P == '0' && W == '0' then UNDEFINED;
+      // if Rn == '1111' then SEE LDRSB (literal); if P == '1' && U == '1'
+      // && W == '0' then SEE LDRSBT; if P == '0' && W == '0' then
+      // UNDEFINED;
       if (BitIsClear(opcode, 10) && BitIsClear(opcode, 8))
         return false;
 
@@ -7633,9 +7604,9 @@
       break;
 
     case eEncodingA1: {
-      // if Rn == '1111' then SEE LDRSB (literal);
-      // if P == '0' && W == '1' then SEE LDRSBT;
-      // t == UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L, 32);
+      // if Rn == '1111' then SEE LDRSB (literal); if P == '0' && W == '1'
+      // then SEE LDRSBT; t == UInt(Rt); n = UInt(Rn); imm32 =
+      // ZeroExtend(imm4H:imm4L, 32);
       t = Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
 
@@ -7643,8 +7614,8 @@
       uint32_t imm4L = Bits32(opcode, 3, 0);
       imm32 = (imm4H << 4) | imm4L;
 
-      // index = (P == '1');	add = (U == '1');	wback = (P == '0') ||
-      // (W == '1');
+      // index = (P == '1');     add = (U == '1');       wback = (P ==
+      // '0') || (W == '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = (BitIsClear(opcode, 24) || BitIsSet(opcode, 21));
@@ -7709,9 +7680,9 @@
   return true;
 }
 
-// LDRSB (literal) calculates an address from the PC value and an immediate
-// offset, loads a byte from memory,
-// sign-extends it to form a 32-bit word, and writes tit to a register.
+// LDRSB (literal) calculates an address from the PC value and an
+// immediate offset, loads a byte from memory, sign-extends it to form a
+// 32-bit word, and writes tit to a register.
 bool EmulateInstructionARM::EmulateLDRSBLiteral(const uint32_t opcode,
                                                 const ARMEncoding encoding) {
 #if 0
@@ -7745,7 +7716,8 @@
       break;
 
     case eEncodingA1: {
-      // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U == '1');
+      // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U ==
+      // '1');
       t = Bits32(opcode, 15, 12);
       uint32_t imm4H = Bits32(opcode, 11, 8);
       uint32_t imm4L = Bits32(opcode, 3, 0);
@@ -7796,11 +7768,10 @@
   return true;
 }
 
-// LDRSB (register) calculates an address from a base register value and an
-// offset register value, loadsa byte from
-// memory, sign-extends it to form a 32-bit word, and writes it to a register.
-// The offset register value can be
-// shifted left by 0, 1, 2, or 3 bits.
+// LDRSB (register) calculates an address from a base register value and
+// an offset register value, loadsa byte from memory, sign-extends it to
+// form a 32-bit word, and writes it to a register. The offset register
+// value can be shifted left by 0, 1, 2, or 3 bits.
 bool EmulateInstructionARM::EmulateLDRSBRegister(const uint32_t opcode,
                                                  const ARMEncoding encoding) {
 #if 0
@@ -7846,8 +7817,8 @@
 
     case eEncodingT2:
       // if Rt == '1111' then SEE PLI;
-      // if Rn == '1111' then SEE LDRSB (literal);
-      // t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
+      // if Rn == '1111' then SEE LDRSB (literal); t = UInt(Rt); n =
+      // UInt(Rn); m = UInt(Rm);
       t = Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
@@ -7867,14 +7838,14 @@
       break;
 
     case eEncodingA1:
-      // if P == '0' && W == '1' then SEE LDRSBT;
-      // t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
+      // if P == '0' && W == '1' then SEE LDRSBT; t = UInt(Rt); n =
+      // UInt(Rn); m = UInt(Rm);
       t = Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
 
-      // index = (P == '1');	add = (U == '1');	wback = (P == '0') ||
-      // (W == '1');
+      // index = (P == '1');     add = (U == '1');       wback = (P ==
+      // '0') || (W == '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = BitIsClear(opcode, 24) || BitIsSet(opcode, 21);
@@ -7957,11 +7928,10 @@
   return true;
 }
 
-// LDRSH (immediate) calculates an address from a base register value and an
-// immediate offset, loads a halfword from
-// memory, sign-extends it to form a 32-bit word, and writes it to a register.
-// It can use offset, post-indexed, or
-// pre-indexed addressing.
+// LDRSH (immediate) calculates an address from a base register value and
+// an immediate offset, loads a halfword from memory, sign-extends it to
+// form a 32-bit word, and writes it to a register. It can use offset,
+// post-indexed, or pre-indexed addressing.
 bool EmulateInstructionARM::EmulateLDRSHImmediate(const uint32_t opcode,
                                                   const ARMEncoding encoding) {
 #if 0
@@ -7990,9 +7960,9 @@
     // EncodingSpecificOperations(); NullCheckIfThumbEE(n);
     switch (encoding) {
     case eEncodingT1:
-      // if Rn == '1111' then SEE LDRSH (literal);
-      // if Rt == '1111' then SEE "Unallocated memory hints";
-      // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
+      // if Rn == '1111' then SEE LDRSH (literal); if Rt == '1111' then
+      // SEE "Unallocated memory hints"; t = UInt(Rt); n = UInt(Rn); imm32
+      // = ZeroExtend(imm12, 32);
       t = Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
       imm32 = Bits32(opcode, 11, 0);
@@ -8009,11 +7979,10 @@
       break;
 
     case eEncodingT2:
-      // if Rn == '1111' then SEE LDRSH (literal);
-      // if Rt == '1111' && P == '1' && U == '0' && W == '0' then SEE
-      // "Unallocated memory hints";
-      // if P == '1' && U == '1' && W == '0' then SEE LDRSHT;
-      // if P == '0' && W == '0' then UNDEFINED;
+      // if Rn == '1111' then SEE LDRSH (literal); if Rt == '1111' && P ==
+      // '1' && U == '0' && W == '0' then SEE "Unallocated memory hints";
+      // if P == '1' && U == '1' && W == '0' then SEE LDRSHT; if P == '0'
+      // && W == '0' then UNDEFINED;
       if (BitIsClear(opcode, 10) && BitIsClear(opcode, 8))
         return false;
 
@@ -8034,17 +8003,17 @@
       break;
 
     case eEncodingA1: {
-      // if Rn == '1111' then SEE LDRSH (literal);
-      // if P == '0' && W == '1' then SEE LDRSHT;
-      // t == UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L, 32);
+      // if Rn == '1111' then SEE LDRSH (literal); if P == '0' && W == '1'
+      // then SEE LDRSHT; t == UInt(Rt); n = UInt(Rn); imm32 =
+      // ZeroExtend(imm4H:imm4L, 32);
       t = Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
       uint32_t imm4H = Bits32(opcode, 11, 8);
       uint32_t imm4L = Bits32(opcode, 3, 0);
       imm32 = (imm4H << 4) | imm4L;
 
-      // index = (P == '1');	add = (U == '1');	wback = (P == '0') ||
-      // (W == '1');
+      // index = (P == '1');     add = (U == '1');       wback = (P ==
+      // '0') || (W == '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = BitIsClear(opcode, 24) || BitIsSet(opcode, 21);
@@ -8118,9 +8087,9 @@
   return true;
 }
 
-// LDRSH (literal) calculates an address from the PC value and an immediate
-// offset, loads a halfword from memory,
-// sign-extends it to from a 32-bit word, and writes it to a register.
+// LDRSH (literal) calculates an address from the PC value and an
+// immediate offset, loads a halfword from memory, sign-extends it to from
+// a 32-bit word, and writes it to a register.
 bool EmulateInstructionARM::EmulateLDRSHLiteral(const uint32_t opcode,
                                                 const ARMEncoding encoding) {
 #if 0
@@ -8145,8 +8114,8 @@
     // EncodingSpecificOperations(); NullCheckIfThumbEE(15);
     switch (encoding) {
     case eEncodingT1:
-      // if Rt == '1111' then SEE "Unallocated memory hints";
-      // t = UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
+      // if Rt == '1111' then SEE "Unallocated memory hints"; t =
+      // UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
       t = Bits32(opcode, 15, 12);
       imm32 = Bits32(opcode, 11, 0);
       add = BitIsSet(opcode, 23);
@@ -8158,7 +8127,8 @@
       break;
 
     case eEncodingA1: {
-      // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U == '1');
+      // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U ==
+      // '1');
       t = Bits32(opcode, 15, 12);
       uint32_t imm4H = Bits32(opcode, 11, 8);
       uint32_t imm4L = Bits32(opcode, 3, 0);
@@ -8217,11 +8187,10 @@
   return true;
 }
 
-// LDRSH (register) calculates an address from a base register value and an
-// offset register value, loads a halfword
-// from memory, sign-extends it to form a 32-bit word, and writes it to a
-// register.  The offset register value can be
-// shifted left by 0, 1, 2, or 3 bits.
+// LDRSH (register) calculates an address from a base register value and
+// an offset register value, loads a halfword from memory, sign-extends it
+// to form a 32-bit word, and writes it to a register.  The offset
+// register value can be shifted left by 0, 1, 2, or 3 bits.
 bool EmulateInstructionARM::EmulateLDRSHRegister(const uint32_t opcode,
                                                  const ARMEncoding encoding) {
 #if 0
@@ -8253,9 +8222,8 @@
     // EncodingSpecificOperations(); NullCheckIfThumbEE(n);
     switch (encoding) {
     case eEncodingT1:
-      // if CurrentInstrSet() == InstrSet_ThumbEE then SEE "Modified operation
-      // in ThumbEE";
-      // t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
+      // if CurrentInstrSet() == InstrSet_ThumbEE then SEE "Modified
+      // operation in ThumbEE"; t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
       t = Bits32(opcode, 2, 0);
       n = Bits32(opcode, 5, 3);
       m = Bits32(opcode, 8, 6);
@@ -8272,9 +8240,9 @@
       break;
 
     case eEncodingT2:
-      // if Rn == '1111' then SEE LDRSH (literal);
-      // if Rt == '1111' then SEE "Unallocated memory hints";
-      // t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
+      // if Rn == '1111' then SEE LDRSH (literal); if Rt == '1111' then
+      // SEE "Unallocated memory hints"; t = UInt(Rt); n = UInt(Rn); m =
+      // UInt(Rm);
       t = Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
@@ -8295,14 +8263,14 @@
       break;
 
     case eEncodingA1:
-      // if P == '0' && W == '1' then SEE LDRSHT;
-      // t = UInt(Rt); n = UInt(Rn); m = UInt(Rm);
+      // if P == '0' && W == '1' then SEE LDRSHT; t = UInt(Rt); n =
+      // UInt(Rn); m = UInt(Rm);
       t = Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
 
-      // index = (P == '1');	add = (U == '1');	wback = (P == '0') ||
-      // (W == '1');
+      // index = (P == '1');     add = (U == '1');       wback = (P ==
+      // '0') || (W == '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = BitIsClear(opcode, 24) || BitIsSet(opcode, 21);
@@ -8398,10 +8366,10 @@
   return true;
 }
 
-// SXTB extracts an 8-bit value from a register, sign-extends it to 32 bits, and
-// writes the result to the destination
-// register.  You can specifiy a rotation by 0, 8, 16, or 24 bits before
-// extracting the 8-bit value.
+// SXTB extracts an 8-bit value from a register, sign-extends it to 32
+// bits, and writes the result to the destination register.  You can
+// specifiy a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit
+// value.
 bool EmulateInstructionARM::EmulateSXTB(const uint32_t opcode,
                                         const ARMEncoding encoding) {
 #if 0
@@ -8483,10 +8451,10 @@
   return true;
 }
 
-// SXTH extracts a 16-bit value from a register, sign-extends it to 32 bits, and
-// writes the result to the destination
-// register.  You can specify a rotation by 0, 8, 16, or 24 bits before
-// extracting the 16-bit value.
+// SXTH extracts a 16-bit value from a register, sign-extends it to 32
+// bits, and writes the result to the destination register.  You can
+// specify a rotation by 0, 8, 16, or 24 bits before extracting the 16-bit
+// value.
 bool EmulateInstructionARM::EmulateSXTH(const uint32_t opcode,
                                         const ARMEncoding encoding) {
 #if 0
@@ -8568,10 +8536,10 @@
   return true;
 }
 
-// UXTB extracts an 8-bit value from a register, zero-extneds it to 32 bits, and
-// writes the result to the destination
-// register.  You can specify a rotation by 0, 8, 16, or 24 bits before
-// extracting the 8-bit value.
+// UXTB extracts an 8-bit value from a register, zero-extneds it to 32
+// bits, and writes the result to the destination register.  You can
+// specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit
+// value.
 bool EmulateInstructionARM::EmulateUXTB(const uint32_t opcode,
                                         const ARMEncoding encoding) {
 #if 0
@@ -8651,10 +8619,10 @@
   return true;
 }
 
-// UXTH extracts a 16-bit value from a register, zero-extends it to 32 bits, and
-// writes the result to the destination
-// register.  You can specify a rotation by 0, 8, 16, or 24 bits before
-// extracting the 16-bit value.
+// UXTH extracts a 16-bit value from a register, zero-extends it to 32
+// bits, and writes the result to the destination register.  You can
+// specify a rotation by 0, 8, 16, or 24 bits before extracting the 16-bit
+// value.
 bool EmulateInstructionARM::EmulateUXTH(const uint32_t opcode,
                                         const ARMEncoding encoding) {
 #if 0
@@ -8733,9 +8701,8 @@
   return true;
 }
 
-// RFE (Return From Exception) loads the PC and the CPSR from the word at the
-// specified address and the following
-// word respectively.
+// RFE (Return From Exception) loads the PC and the CPSR from the word at
+// the specified address and the following word respectively.
 bool EmulateInstructionARM::EmulateRFE(const uint32_t opcode,
                                        const ARMEncoding encoding) {
 #if 0
@@ -8780,7 +8747,8 @@
       break;
 
     case eEncodingT2:
-      // n = UInt(Rn); wback = (W == '1'); increment = TRUE; wordhigher = FALSE;
+      // n = UInt(Rn); wback = (W == '1'); increment = TRUE; wordhigher =
+      // FALSE;
       n = Bits32(opcode, 19, 16);
       wback = BitIsSet(opcode, 21);
       increment = true;
@@ -8815,8 +8783,8 @@
       return false;
     }
 
-    // if !CurrentModeIsPrivileged() || CurrentInstrSet() == InstrSet_ThumbEE
-    // then
+    // if !CurrentModeIsPrivileged() || CurrentInstrSet() ==
+    // InstrSet_ThumbEE then
     if (!CurrentModeIsPrivileged())
       // UNPREDICTABLE;
       return false;
@@ -8879,10 +8847,9 @@
 }
 
 // Bitwise Exclusive OR (immediate) performs a bitwise exclusive OR of a
-// register value and an immediate value,
-// and writes the result to the destination register.  It can optionally update
-// the condition flags based on
-// the result.
+// register value and an immediate value, and writes the result to the
+// destination register.  It can optionally update the condition flags
+// based on the result.
 bool EmulateInstructionARM::EmulateEORImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -8957,11 +8924,10 @@
   return true;
 }
 
-// Bitwise Exclusive OR (register) performs a bitwise exclusive OR of a register
-// value and an
-// optionally-shifted register value, and writes the result to the destination
-// register.
-// It can optionally update the condition flags based on the result.
+// Bitwise Exclusive OR (register) performs a bitwise exclusive OR of a
+// register value and an optionally-shifted register value, and writes the
+// result to the destination register. It can optionally update the
+// condition flags based on the result.
 bool EmulateInstructionARM::EmulateEORReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -9050,11 +9016,10 @@
   return true;
 }
 
-// Bitwise OR (immediate) performs a bitwise (inclusive) OR of a register value
-// and an immediate value, and
-// writes the result to the destination register.  It can optionally update the
-// condition flags based
-// on the result.
+// Bitwise OR (immediate) performs a bitwise (inclusive) OR of a register
+// value and an immediate value, and writes the result to the destination
+// register.  It can optionally update the condition flags based on the
+// result.
 bool EmulateInstructionARM::EmulateORRImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -9127,11 +9092,10 @@
   return true;
 }
 
-// Bitwise OR (register) performs a bitwise (inclusive) OR of a register value
-// and an optionally-shifted register
-// value, and writes the result to the destination register.  It can optionally
-// update the condition flags based
-// on the result.
+// Bitwise OR (register) performs a bitwise (inclusive) OR of a register
+// value and an optionally-shifted register value, and writes the result
+// to the destination register.  It can optionally update the condition
+// flags based on the result.
 bool EmulateInstructionARM::EmulateORRReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -9218,10 +9182,9 @@
   return true;
 }
 
-// Reverse Subtract (immediate) subtracts a register value from an immediate
-// value, and writes the result to
-// the destination register. It can optionally update the condition flags based
-// on the result.
+// Reverse Subtract (immediate) subtracts a register value from an
+// immediate value, and writes the result to the destination register. It
+// can optionally update the condition flags based on the result.
 bool EmulateInstructionARM::EmulateRSBImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -9295,9 +9258,9 @@
 }
 
 // Reverse Subtract (register) subtracts a register value from an
-// optionally-shifted register value, and writes the
-// result to the destination register. It can optionally update the condition
-// flags based on the result.
+// optionally-shifted register value, and writes the result to the
+// destination register. It can optionally update the condition flags
+// based on the result.
 bool EmulateInstructionARM::EmulateRSBReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -9376,11 +9339,10 @@
   return true;
 }
 
-// Reverse Subtract with Carry (immediate) subtracts a register value and the
-// value of NOT (Carry flag) from
-// an immediate value, and writes the result to the destination register. It can
-// optionally update the condition
-// flags based on the result.
+// Reverse Subtract with Carry (immediate) subtracts a register value and
+// the value of NOT (Carry flag) from an immediate value, and writes the
+// result to the destination register. It can optionally update the
+// condition flags based on the result.
 bool EmulateInstructionARM::EmulateRSCImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -9439,11 +9401,10 @@
   return true;
 }
 
-// Reverse Subtract with Carry (register) subtracts a register value and the
-// value of NOT (Carry flag) from an
-// optionally-shifted register value, and writes the result to the destination
-// register. It can optionally update the
-// condition flags based on the result.
+// Reverse Subtract with Carry (register) subtracts a register value and
+// the value of NOT (Carry flag) from an optionally-shifted register
+// value, and writes the result to the destination register. It can
+// optionally update the condition flags based on the result.
 bool EmulateInstructionARM::EmulateRSCReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -9512,10 +9473,10 @@
   return true;
 }
 
-// Subtract with Carry (immediate) subtracts an immediate value and the value of
-// NOT (Carry flag) from a register value, and writes the result to the
-// destination register.
-// It can optionally update the condition flags based on the result.
+// Subtract with Carry (immediate) subtracts an immediate value and the
+// value of NOT (Carry flag) from a register value, and writes the result
+// to the destination register. It can optionally update the condition
+// flags based on the result.
 bool EmulateInstructionARM::EmulateSBCImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -9582,11 +9543,10 @@
   return true;
 }
 
-// Subtract with Carry (register) subtracts an optionally-shifted register value
-// and the value of
-// NOT (Carry flag) from a register value, and writes the result to the
-// destination register.
-// It can optionally update the condition flags based on the result.
+// Subtract with Carry (register) subtracts an optionally-shifted register
+// value and the value of NOT (Carry flag) from a register value, and
+// writes the result to the destination register. It can optionally update
+// the condition flags based on the result.
 bool EmulateInstructionARM::EmulateSBCReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -9671,10 +9631,9 @@
   return true;
 }
 
-// This instruction subtracts an immediate value from a register value, and
-// writes the result
-// to the destination register.  It can optionally update the condition flags
-// based on the result.
+// This instruction subtracts an immediate value from a register value,
+// and writes the result to the destination register.  It can optionally
+// update the condition flags based on the result.
 bool EmulateInstructionARM::EmulateSUBImmThumb(const uint32_t opcode,
                                                const ARMEncoding encoding) {
 #if 0
@@ -9765,10 +9724,9 @@
   return true;
 }
 
-// This instruction subtracts an immediate value from a register value, and
-// writes the result
-// to the destination register.  It can optionally update the condition flags
-// based on the result.
+// This instruction subtracts an immediate value from a register value,
+// and writes the result to the destination register.  It can optionally
+// update the condition flags based on the result.
 bool EmulateInstructionARM::EmulateSUBImmARM(const uint32_t opcode,
                                              const ARMEncoding encoding) {
 #if 0
@@ -9843,10 +9801,9 @@
   return true;
 }
 
-// Test Equivalence (immediate) performs a bitwise exclusive OR operation on a
-// register value and an
-// immediate value.  It updates the condition flags based on the result, and
-// discards the result.
+// Test Equivalence (immediate) performs a bitwise exclusive OR operation
+// on a register value and an immediate value.  It updates the condition
+// flags based on the result, and discards the result.
 bool EmulateInstructionARM::EmulateTEQImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -9903,11 +9860,10 @@
   return true;
 }
 
-// Test Equivalence (register) performs a bitwise exclusive OR operation on a
-// register value and an
-// optionally-shifted register value.  It updates the condition flags based on
-// the result, and discards
-// the result.
+// Test Equivalence (register) performs a bitwise exclusive OR operation
+// on a register value and an optionally-shifted register value.  It
+// updates the condition flags based on the result, and discards the
+// result.
 bool EmulateInstructionARM::EmulateTEQReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -9971,9 +9927,9 @@
   return true;
 }
 
-// Test (immediate) performs a bitwise AND operation on a register value and an
-// immediate value.
-// It updates the condition flags based on the result, and discards the result.
+// Test (immediate) performs a bitwise AND operation on a register value
+// and an immediate value. It updates the condition flags based on the
+// result, and discards the result.
 bool EmulateInstructionARM::EmulateTSTImm(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -10030,9 +9986,9 @@
   return true;
 }
 
-// Test (register) performs a bitwise AND operation on a register value and an
-// optionally-shifted register value.
-// It updates the condition flags based on the result, and discards the result.
+// Test (register) performs a bitwise AND operation on a register value
+// and an optionally-shifted register value. It updates the condition
+// flags based on the result, and discards the result.
 bool EmulateInstructionARM::EmulateTSTReg(const uint32_t opcode,
                                           const ARMEncoding encoding) {
 #if 0
@@ -10327,7 +10283,8 @@
 
     switch (encoding) {
     case eEncodingT1:
-      // d = UInt(Rd); n = UInt(Rn); m = UInt(Rm); setflags = !InITBlock();
+      // d = UInt(Rd); n = UInt(Rn); m = UInt(Rm); setflags =
+      // !InITBlock();
       d = Bits32(opcode, 2, 0);
       n = Bits32(opcode, 5, 3);
       m = Bits32(opcode, 8, 6);
@@ -10366,8 +10323,8 @@
       break;
 
     case eEncodingA1:
-      // if Rn == '1101' then SEE SUB (SP minus register);
-      // d = UInt(Rd); n = UInt(Rn); m = UInt(Rm); setflags = (S == '1');
+      // if Rn == '1101' then SEE SUB (SP minus register); d = UInt(Rd); n
+      // = UInt(Rn); m = UInt(Rm); setflags = (S == '1');
       d = Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
@@ -10404,14 +10361,9 @@
     AddWithCarryResult res = AddWithCarry(Rn, ~shifted, 1);
 
     // if d == 15 then // Can only occur for ARM encoding
-    // ALUWritePC(result); // setflags is always FALSE here
-    // else
-    // R[d] = result;
-    // if setflags then
-    // APSR.N = result<31>;
-    // APSR.Z = IsZeroBit(result);
-    // APSR.C = carry;
-    // APSR.V = overflow;
+    // ALUWritePC(result); // setflags is always FALSE here else R[d] =
+    // result; if setflags then APSR.N = result<31>; APSR.Z =
+    // IsZeroBit(result); APSR.C = carry; APSR.V = overflow;
 
     EmulateInstruction::Context context;
     context.type = eContextArithmetic;
@@ -10429,10 +10381,10 @@
 }
 
 // A8.6.202 STREX
-// Store Register Exclusive calculates an address from a base register value and
-// an immediate offset, and stores a
-// word from a register to memory if the executing processor has exclusive
-// access to the memory addressed.
+// Store Register Exclusive calculates an address from a base register
+// value and an immediate offset, and stores a word from a register to
+// memory if the executing processor has exclusive access to the memory
+// addressed.
 bool EmulateInstructionARM::EmulateSTREX(const uint32_t opcode,
                                          const ARMEncoding encoding) {
 #if 0
@@ -10457,8 +10409,8 @@
 
     switch (encoding) {
     case eEncodingT1:
-      // d = UInt(Rd); t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8:'00',
-      // 32);
+      // d = UInt(Rd); t = UInt(Rt); n = UInt(Rn); imm32 =
+      // ZeroExtend(imm8:'00', 32);
       d = Bits32(opcode, 11, 8);
       t = Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
@@ -10475,8 +10427,8 @@
       break;
 
     case eEncodingA1:
-      // d = UInt(Rd); t = UInt(Rt); n = UInt(Rn); imm32 = Zeros(32); // Zero
-      // offset
+      // d = UInt(Rd); t = UInt(Rt); n = UInt(Rn); imm32 = Zeros(32); //
+      // Zero offset
       d = Bits32(opcode, 15, 12);
       t = Bits32(opcode, 3, 0);
       n = Bits32(opcode, 19, 16);
@@ -10511,9 +10463,9 @@
     context.type = eContextRegisterStore;
     context.SetRegisterToRegisterPlusOffset(data_reg, base_reg, imm32);
 
-    // if ExclusiveMonitorsPass(address,4) then
-    // if (ExclusiveMonitorsPass (address, addr_byte_size)) -- For now, for the
-    // sake of emulation, we will say this
+    // if ExclusiveMonitorsPass(address,4) then if (ExclusiveMonitorsPass
+    // (address, addr_byte_size)) -- For now, for the sake of emulation,
+    // we will say this
     //                                                         always return
     //                                                         true.
     if (true) {
@@ -10572,7 +10524,8 @@
       n = Bits32(opcode, 19, 16);
       imm32 = Bits32(opcode, 11, 0);
 
-      // index = (P == '1'); add = (U == '1'); wback = (P == '0') || (W == '1');
+      // index = (P == '1'); add = (U == '1'); wback = (P == '0') || (W ==
+      // '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = BitIsClear(opcode, 24) || BitIsSet(opcode, 21);
@@ -10663,13 +10616,14 @@
     case eEncodingA1:
       // if P == '0' && W == '1' then SEE STRT;
       // if Rn == '1101' && P == '1' && U == '0' && W == '1' && imm12 ==
-      // '000000000100' then SEE PUSH;
-      // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
+      // '000000000100' then SEE PUSH; t = UInt(Rt); n = UInt(Rn); imm32 =
+      // ZeroExtend(imm12, 32);
       t = Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
       imm32 = Bits32(opcode, 11, 0);
 
-      // index = (P == '1'); add = (U == '1'); wback = (P == '0') || (W == '1');
+      // index = (P == '1'); add = (U == '1'); wback = (P == '0') || (W ==
+      // '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = BitIsClear(opcode, 24) || BitIsSet(opcode, 21);
@@ -10741,10 +10695,10 @@
 }
 
 // A8.6.66 LDRD (immediate)
-// Load Register Dual (immediate) calculates an address from a base register
-// value and an immediate offset, loads two
-// words from memory, and writes them to two registers.  It can use offset,
-// post-indexed, or pre-indexed addressing.
+// Load Register Dual (immediate) calculates an address from a base
+// register value and an immediate offset, loads two words from memory,
+// and writes them to two registers.  It can use offset, post-indexed, or
+// pre-indexed addressing.
 bool EmulateInstructionARM::EmulateLDRDImmediate(const uint32_t opcode,
                                                  const ARMEncoding encoding) {
 #if 0
@@ -10770,10 +10724,9 @@
 
     switch (encoding) {
     case eEncodingT1:
-      // if P == '0' && W == '0' then SEE 'Related encodings';
-      // if Rn == '1111' then SEE LDRD (literal);
-      // t = UInt(Rt); t2 = UInt(Rt2); n = UInt(Rn); imm32 =
-      // ZeroExtend(imm8:'00', 32);
+      // if P == '0' && W == '0' then SEE 'Related encodings'; if Rn ==
+      // '1111' then SEE LDRD (literal); t = UInt(Rt); t2 = UInt(Rt2); n =
+      // UInt(Rn); imm32 = ZeroExtend(imm8:'00', 32);
       t = Bits32(opcode, 15, 12);
       t2 = Bits32(opcode, 11, 8);
       n = Bits32(opcode, 19, 16);
@@ -10795,10 +10748,9 @@
       break;
 
     case eEncodingA1:
-      // if Rn == '1111' then SEE LDRD (literal);
-      // if Rt<0> == '1' then UNPREDICTABLE;
-      // t = UInt(Rt); t2 = t+1; n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L,
-      // 32);
+      // if Rn == '1111' then SEE LDRD (literal); if Rt<0> == '1' then
+      // UNPREDICTABLE; t = UInt(Rt); t2 = t+1; n = UInt(Rn); imm32 =
+      // ZeroExtend(imm4H:imm4L, 32);
       t = Bits32(opcode, 15, 12);
       if (BitIsSet(t, 0))
         return false;
@@ -10806,7 +10758,8 @@
       n = Bits32(opcode, 19, 16);
       imm32 = (Bits32(opcode, 11, 8) << 4) | Bits32(opcode, 3, 0);
 
-      // index = (P == '1'); add = (U == '1'); wback = (P == '0') || (W == '1');
+      // index = (P == '1'); add = (U == '1'); wback = (P == '0') || (W ==
+      // '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = BitIsClear(opcode, 24) || BitIsSet(opcode, 21);
@@ -10890,10 +10843,10 @@
 }
 
 // A8.6.68 LDRD (register)
-// Load Register Dual (register) calculates an address from a base register
-// value and a register offset, loads two
-// words from memory, and writes them to two registers.  It can use offset,
-// post-indexed or pre-indexed addressing.
+// Load Register Dual (register) calculates an address from a base
+// register value and a register offset, loads two words from memory, and
+// writes them to two registers.  It can use offset, post-indexed or pre-
+// indexed addressing.
 bool EmulateInstructionARM::EmulateLDRDRegister(const uint32_t opcode,
                                                 const ARMEncoding encoding) {
 #if 0
@@ -10928,7 +10881,8 @@
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
 
-      // index = (P == '1'); add = (U == '1'); wback = (P == '0') || (W == '1');
+      // index = (P == '1'); add = (U == '1'); wback = (P == '0') || (W ==
+      // '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = BitIsClear(opcode, 24) || BitIsSet(opcode, 21);
@@ -11020,10 +10974,10 @@
 }
 
 // A8.6.200 STRD (immediate)
-// Store Register Dual (immediate) calculates an address from a base register
-// value and an immediate offset, and
-// stores two words from two registers to memory.  It can use offset,
-// post-indexed, or pre-indexed addressing.
+// Store Register Dual (immediate) calculates an address from a base
+// register value and an immediate offset, and stores two words from two
+// registers to memory.  It can use offset, post-indexed, or pre-indexed
+// addressing.
 bool EmulateInstructionARM::EmulateSTRDImm(const uint32_t opcode,
                                            const ARMEncoding encoding) {
 #if 0
@@ -11049,8 +11003,8 @@
 
     switch (encoding) {
     case eEncodingT1:
-      // if P == '0' && W == '0' then SEE 'Related encodings';
-      // t = UInt(Rt); t2 = UInt(Rt2); n = UInt(Rn); imm32 =
+      // if P == '0' && W == '0' then SEE 'Related encodings'; t =
+      // UInt(Rt); t2 = UInt(Rt2); n = UInt(Rn); imm32 =
       // ZeroExtend(imm8:'00', 32);
       t = Bits32(opcode, 15, 12);
       t2 = Bits32(opcode, 11, 8);
@@ -11074,8 +11028,8 @@
 
     case eEncodingA1:
       // if Rt<0> == '1' then UNPREDICTABLE;
-      // t = UInt(Rt); t2 = t+1; n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L,
-      // 32);
+      // t = UInt(Rt); t2 = t+1; n = UInt(Rn); imm32 =
+      // ZeroExtend(imm4H:imm4L, 32);
       t = Bits32(opcode, 15, 12);
       if (BitIsSet(t, 0))
         return false;
@@ -11084,7 +11038,8 @@
       n = Bits32(opcode, 19, 16);
       imm32 = (Bits32(opcode, 11, 8) << 4) | Bits32(opcode, 3, 0);
 
-      // index = (P == '1'); add = (U == '1'); wback = (P == '0') || (W == '1');
+      // index = (P == '1'); add = (U == '1'); wback = (P == '0') || (W ==
+      // '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = BitIsClear(opcode, 24) || BitIsSet(opcode, 21);
@@ -11212,7 +11167,8 @@
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
 
-      // index = (P == '1'); add = (U == '1'); wback = (P == '0') || (W == '1');
+      // index = (P == '1'); add = (U == '1'); wback = (P == '0') || (W ==
+      // '1');
       index = BitIsSet(opcode, 24);
       add = BitIsSet(opcode, 23);
       wback = BitIsClear(opcode, 24) || BitIsSet(opcode, 21);
@@ -11313,9 +11269,9 @@
 }
 
 // A8.6.319 VLDM
-// Vector Load Multiple loads multiple extension registers from consecutive
-// memory locations using an address from
-// an ARM core register.
+// Vector Load Multiple loads multiple extension registers from
+// consecutive memory locations using an address from an ARM core
+// register.
 bool EmulateInstructionARM::EmulateVLDM(const uint32_t opcode,
                                         const ARMEncoding encoding) {
 #if 0
@@ -11328,7 +11284,8 @@
                 S[d+r] = MemA[address,4]; address = address+4;
             else
                 word1 = MemA[address,4]; word2 = MemA[address+4,4]; address = address+8;
-                // Combine the word-aligned words in the correct order for current endianness.
+                // Combine the word-aligned words in the correct order for
+                // current endianness.
                 D[d+r] = if BigEndian() then word1:word2 else word2:word1;
 #endif
 
@@ -11347,15 +11304,15 @@
     case eEncodingT1:
     case eEncodingA1:
       // if P == '0' && U == '0' && W == '0' then SEE 'Related encodings';
-      // if P == '0' && U == '1' && W == '1' && Rn == '1101' then SEE VPOP;
-      // if P == '1' && W == '0' then SEE VLDR;
-      // if P == U && W == '1' then UNDEFINED;
+      // if P == '0' && U == '1' && W == '1' && Rn == '1101' then SEE
+      // VPOP; if P == '1' && W == '0' then SEE VLDR; if P == U && W ==
+      // '1' then UNDEFINED;
       if ((Bit32(opcode, 24) == Bit32(opcode, 23)) && BitIsSet(opcode, 21))
         return false;
 
-      // // Remaining combinations are PUW = 010 (IA without !), 011 (IA with
-      // !), 101 (DB with !)
-      // single_regs = FALSE; add = (U == '1'); wback = (W == '1');
+      // // Remaining combinations are PUW = 010 (IA without !), 011 (IA
+      // with !), 101 (DB with !) single_regs = FALSE; add = (U == '1');
+      // wback = (W == '1');
       single_regs = false;
       add = BitIsSet(opcode, 23);
       wback = BitIsSet(opcode, 21);
@@ -11382,16 +11339,15 @@
     case eEncodingT2:
     case eEncodingA2:
       // if P == '0' && U == '0' && W == '0' then SEE 'Related encodings';
-      // if P == '0' && U == '1' && W == '1' && Rn == '1101' then SEE VPOP;
-      // if P == '1' && W == '0' then SEE VLDR;
-      // if P == U && W == '1' then UNDEFINED;
+      // if P == '0' && U == '1' && W == '1' && Rn == '1101' then SEE
+      // VPOP; if P == '1' && W == '0' then SEE VLDR; if P == U && W ==
+      // '1' then UNDEFINED;
       if ((Bit32(opcode, 24) == Bit32(opcode, 23)) && BitIsSet(opcode, 21))
         return false;
 
-      // // Remaining combinations are PUW = 010 (IA without !), 011 (IA with
-      // !), 101 (DB with !)
-      // single_regs = TRUE; add = (U == '1'); wback = (W == '1'); d =
-      // UInt(Vd:D); n = UInt(Rn);
+      // // Remaining combinations are PUW = 010 (IA without !), 011 (IA
+      // with !), 101 (DB with !) single_regs = TRUE; add = (U == '1');
+      // wback = (W == '1'); d = UInt(Vd:D); n = UInt(Rn);
       single_regs = true;
       add = BitIsSet(opcode, 23);
       wback = BitIsSet(opcode, 21);
@@ -11483,9 +11439,9 @@
           return false;
 
         address = address + 8;
-        // // Combine the word-aligned words in the correct order for current
-        // endianness.
-        // D[d+r] = if BigEndian() then word1:word2 else word2:word1;
+        // // Combine the word-aligned words in the correct order for
+        // current endianness. D[d+r] = if BigEndian() then word1:word2
+        // else word2:word1;
         uint64_t data;
         if (GetByteOrder() == eByteOrderBig) {
           data = word1;
@@ -11505,9 +11461,9 @@
 }
 
 // A8.6.399 VSTM
-// Vector Store Multiple stores multiple extension registers to consecutive
-// memory locations using an address from an
-// ARM core register.
+// Vector Store Multiple stores multiple extension registers to
+// consecutive memory locations using an address from an ARM core
+// register.
 bool EmulateInstructionARM::EmulateVSTM(const uint32_t opcode,
                                         const ARMEncoding encoding) {
 #if 0
@@ -11519,7 +11475,8 @@
             if single_regs then
                 MemA[address,4] = S[d+r]; address = address+4;
             else
-                // Store as two word-aligned words in the correct order for current endianness.
+                // Store as two word-aligned words in the correct order
+                // for current endianness.
                 MemA[address,4] = if BigEndian() then D[d+r]<63:32> else D[d+r]<31:0>;
                 MemA[address+4,4] = if BigEndian() then D[d+r]<31:0> else D[d+r]<63:32>;
                 address = address+8;
@@ -11540,15 +11497,15 @@
     case eEncodingT1:
     case eEncodingA1:
       // if P == '0' && U == '0' && W == '0' then SEE 'Related encodings';
-      // if P == '1' && U == '0' && W == '1' && Rn == '1101' then SEE VPUSH;
-      // if P == '1' && W == '0' then SEE VSTR;
-      // if P == U && W == '1' then UNDEFINED;
+      // if P == '1' && U == '0' && W == '1' && Rn == '1101' then SEE
+      // VPUSH; if P == '1' && W == '0' then SEE VSTR; if P == U && W ==
+      // '1' then UNDEFINED;
       if ((Bit32(opcode, 24) == Bit32(opcode, 23)) && BitIsSet(opcode, 21))
         return false;
 
-      // // Remaining combinations are PUW = 010 (IA without !), 011 (IA with
-      // !), 101 (DB with !)
-      // single_regs = FALSE; add = (U == '1'); wback = (W == '1');
+      // // Remaining combinations are PUW = 010 (IA without !), 011 (IA
+      // with !), 101 (DB with !) single_regs = FALSE; add = (U == '1');
+      // wback = (W == '1');
       single_regs = false;
       add = BitIsSet(opcode, 23);
       wback = BitIsSet(opcode, 21);
@@ -11575,16 +11532,15 @@
     case eEncodingT2:
     case eEncodingA2:
       // if P == '0' && U == '0' && W == '0' then SEE 'Related encodings';
-      // if P == '1' && U == '0' && W == '1' && Rn == '1101' then SEE VPUSH;
-      // if P == '1' && W == '0' then SEE VSTR;
-      // if P == U && W == '1' then UNDEFINED;
+      // if P == '1' && U == '0' && W == '1' && Rn == '1101' then SEE
+      // VPUSH; if P == '1' && W == '0' then SEE VSTR; if P == U && W ==
+      // '1' then UNDEFINED;
       if ((Bit32(opcode, 24) == Bit32(opcode, 23)) && BitIsSet(opcode, 21))
         return false;
 
-      // // Remaining combinations are PUW = 010 (IA without !), 011 (IA with
-      // !), 101 (DB with !)
-      // single_regs = TRUE; add = (U == '1'); wback = (W == '1'); d =
-      // UInt(Vd:D); n = UInt(Rn);
+      // // Remaining combinations are PUW = 010 (IA without !), 011 (IA
+      // with !), 101 (DB with !) single_regs = TRUE; add = (U == '1');
+      // wback = (W == '1'); d = UInt(Vd:D); n = UInt(Rn);
       single_regs = true;
       add = BitIsSet(opcode, 23);
       wback = BitIsSet(opcode, 21);
@@ -11664,12 +11620,10 @@
 
         address = address + 4;
       } else {
-        // // Store as two word-aligned words in the correct order for current
-        // endianness.
-        // MemA[address,4] = if BigEndian() then D[d+r]<63:32> else
-        // D[d+r]<31:0>;
-        // MemA[address+4,4] = if BigEndian() then D[d+r]<31:0> else
-        // D[d+r]<63:32>;
+        // // Store as two word-aligned words in the correct order for
+        // current endianness. MemA[address,4] = if BigEndian() then
+        // D[d+r]<63:32> else D[d+r]<31:0>; MemA[address+4,4] = if
+        // BigEndian() then D[d+r]<31:0> else D[d+r]<63:32>;
         uint64_t data = ReadRegisterUnsigned(eRegisterKindDWARF,
                                              start_reg + d + r, 0, &success);
         if (!success)
@@ -11711,9 +11665,8 @@
 }
 
 // A8.6.320
-// This instruction loads a single extension register from memory, using an
-// address from an ARM core register, with
-// an optional offset.
+// This instruction loads a single extension register from memory, using
+// an address from an ARM core register, with an optional offset.
 bool EmulateInstructionARM::EmulateVLDR(const uint32_t opcode,
                                         ARMEncoding encoding) {
 #if 0
@@ -11725,7 +11678,8 @@
             S[d] = MemA[address,4];
         else
             word1 = MemA[address,4]; word2 = MemA[address+4,4];
-            // Combine the word-aligned words in the correct order for current endianness.
+            // Combine the word-aligned words in the correct order for
+            // current endianness.
             D[d] = if BigEndian() then word1:word2 else word2:word1;
 #endif
 
@@ -11741,8 +11695,8 @@
     switch (encoding) {
     case eEncodingT1:
     case eEncodingA1:
-      // single_reg = FALSE; add = (U == '1'); imm32 = ZeroExtend(imm8:'00',
-      // 32);
+      // single_reg = FALSE; add = (U == '1'); imm32 =
+      // ZeroExtend(imm8:'00', 32);
       single_reg = false;
       add = BitIsSet(opcode, 23);
       imm32 = Bits32(opcode, 7, 0) << 2;
@@ -11755,7 +11709,8 @@
 
     case eEncodingT2:
     case eEncodingA2:
-      // single_reg = TRUE; add = (U == '1'); imm32 = ZeroExtend(imm8:'00', 32);
+      // single_reg = TRUE; add = (U == '1'); imm32 =
+      // ZeroExtend(imm8:'00', 32);
       single_reg = true;
       add = BitIsSet(opcode, 23);
       imm32 = Bits32(opcode, 7, 0) << 2;
@@ -11817,9 +11772,9 @@
           MemARead(context, address + 4, addr_byte_size, 0, &success);
       if (!success)
         return false;
-      // // Combine the word-aligned words in the correct order for current
-      // endianness.
-      // D[d] = if BigEndian() then word1:word2 else word2:word1;
+      // // Combine the word-aligned words in the correct order for
+      // current endianness. D[d] = if BigEndian() then word1:word2 else
+      // word2:word1;
       uint64_t data64;
       if (GetByteOrder() == eByteOrderBig) {
         data64 = word1;
@@ -11839,8 +11794,7 @@
 
 // A8.6.400 VSTR
 // This instruction stores a signle extension register to memory, using an
-// address from an ARM core register, with an
-// optional offset.
+// address from an ARM core register, with an optional offset.
 bool EmulateInstructionARM::EmulateVSTR(const uint32_t opcode,
                                         ARMEncoding encoding) {
 #if 0
@@ -11850,7 +11804,8 @@
         if single_reg then
             MemA[address,4] = S[d];
         else
-            // Store as two word-aligned words in the correct order for current endianness.
+            // Store as two word-aligned words in the correct order for
+            // current endianness.
             MemA[address,4] = if BigEndian() then D[d]<63:32> else D[d]<31:0>;
             MemA[address+4,4] = if BigEndian() then D[d]<31:0> else D[d]<63:32>;
 #endif
@@ -11867,8 +11822,8 @@
     switch (encoding) {
     case eEncodingT1:
     case eEncodingA1:
-      // single_reg = FALSE; add = (U == '1'); imm32 = ZeroExtend(imm8:'00',
-      // 32);
+      // single_reg = FALSE; add = (U == '1'); imm32 =
+      // ZeroExtend(imm8:'00', 32);
       single_reg = false;
       add = BitIsSet(opcode, 23);
       imm32 = Bits32(opcode, 7, 0) << 2;
@@ -11877,7 +11832,8 @@
       d = (Bit32(opcode, 22) << 4) | Bits32(opcode, 15, 12);
       n = Bits32(opcode, 19, 16);
 
-      // if n == 15 && CurrentInstrSet() != InstrSet_ARM then UNPREDICTABLE;
+      // if n == 15 && CurrentInstrSet() != InstrSet_ARM then
+      // UNPREDICTABLE;
       if ((n == 15) && (CurrentInstrSet() != eModeARM))
         return false;
 
@@ -11885,7 +11841,8 @@
 
     case eEncodingT2:
     case eEncodingA2:
-      // single_reg = TRUE; add = (U == '1'); imm32 = ZeroExtend(imm8:'00', 32);
+      // single_reg = TRUE; add = (U == '1'); imm32 =
+      // ZeroExtend(imm8:'00', 32);
       single_reg = true;
       add = BitIsSet(opcode, 23);
       imm32 = Bits32(opcode, 7, 0) << 2;
@@ -11894,7 +11851,8 @@
       d = (Bits32(opcode, 15, 12) << 1) | Bit32(opcode, 22);
       n = Bits32(opcode, 19, 16);
 
-      // if n == 15 && CurrentInstrSet() != InstrSet_ARM then UNPREDICTABLE;
+      // if n == 15 && CurrentInstrSet() != InstrSet_ARM then
+      // UNPREDICTABLE;
       if ((n == 15) && (CurrentInstrSet() != eModeARM))
         return false;
 
@@ -11937,10 +11895,10 @@
       if (!MemAWrite(context, address, data, addr_byte_size))
         return false;
     } else {
-      // // Store as two word-aligned words in the correct order for current
-      // endianness.
-      // MemA[address,4] = if BigEndian() then D[d]<63:32> else D[d]<31:0>;
-      // MemA[address+4,4] = if BigEndian() then D[d]<31:0> else D[d]<63:32>;
+      // // Store as two word-aligned words in the correct order for
+      // current endianness. MemA[address,4] = if BigEndian() then
+      // D[d]<63:32> else D[d]<31:0>; MemA[address+4,4] = if BigEndian()
+      // then D[d]<31:0> else D[d]<63:32>;
       uint64_t data =
           ReadRegisterUnsigned(eRegisterKindDWARF, start_reg + d, 0, &success);
       if (!success)
@@ -11970,10 +11928,9 @@
   return true;
 }
 
-// A8.6.307 VLDI1 (multiple single elements)
-// This instruction loads elements from memory into one, two, three or four
-// registers, without de-interleaving.  Every
-// element of each register is loaded.
+// A8.6.307 VLDI1 (multiple single elements) This instruction loads
+// elements from memory into one, two, three or four registers, without
+// de-interleaving.  Every element of each register is loaded.
 bool EmulateInstructionARM::EmulateVLD1Multiple(const uint32_t opcode,
                                                 ARMEncoding encoding) {
 #if 0
@@ -12006,14 +11963,9 @@
     case eEncodingA1: {
       // case type of
       // when '0111'
-      // regs = 1; if align<1> == '1' then UNDEFINED;
-      // when '1010'
-      // regs = 2; if align == '11' then UNDEFINED;
-      // when '0110'
-      // regs = 3; if align<1> == '1' then UNDEFINED;
-      // when '0010'
-      // regs = 4;
-      // otherwise
+      // regs = 1; if align<1> == '1' then UNDEFINED; when '1010' regs =
+      // 2; if align == '11' then UNDEFINED; when '0110' regs = 3; if
+      // align<1> == '1' then UNDEFINED; when '0010' regs = 4; otherwise
       // SEE 'Related encodings';
       uint32_t type = Bits32(opcode, 11, 8);
       uint32_t align = Bits32(opcode, 5, 4);
@@ -12045,7 +11997,8 @@
       else
         alignment = 4 << align;
 
-      // ebytes = 1 << UInt(size); esize = 8 * ebytes; elements = 8 DIV ebytes;
+      // ebytes = 1 << UInt(size); esize = 8 * ebytes; elements = 8 DIV
+      // ebytes;
       ebytes = 1 << Bits32(opcode, 7, 6);
       esize = 8 * ebytes;
       elements = 8 / ebytes;
@@ -12082,7 +12035,8 @@
       return false;
 
     EmulateInstruction::Context context;
-    // if wback then R[n] = R[n] + (if register_index then R[m] else 8*regs);
+    // if wback then R[n] = R[n] + (if register_index then R[m] else
+    // 8*regs);
     if (wback) {
       uint32_t Rm = ReadCoreReg(m, &success);
       if (!success)
@@ -12170,7 +12124,8 @@
         if (BitIsClear(index_align, 0))
           return false;
 
-        // ebytes = 1; esize = 8; index = UInt(index_align<3:1>); alignment = 1;
+        // ebytes = 1; esize = 8; index = UInt(index_align<3:1>);
+        // alignment = 1;
         ebytes = 1;
         esize = 8;
         index = Bits32(index_align, 3, 1);
@@ -12221,8 +12176,8 @@
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
 
-      // wback = (m != 15); register_index = (m != 15 && m != 13); if n == 15
-      // then UNPREDICTABLE;
+      // wback = (m != 15); register_index = (m != 15 && m != 13); if n ==
+      // 15 then UNPREDICTABLE;
       wback = (m != 15);
       register_index = ((m != 15) && (m != 13));
 
@@ -12249,7 +12204,8 @@
       return false;
 
     EmulateInstruction::Context context;
-    // if wback then R[n] = R[n] + (if register_index then R[m] else ebytes);
+    // if wback then R[n] = R[n] + (if register_index then R[m] else
+    // ebytes);
     if (wback) {
       uint32_t Rm = ReadCoreReg(m, &success);
       if (!success)
@@ -12291,8 +12247,7 @@
     if (index > 0)
       mask = mask | Bits64(all_ones, (index * esize) - 1,
                            0); // add 1's to the right of where 'element' goes.
-    // now mask should be 0's where element goes & 1's
-    // everywhere else.
+    // now mask should be 0's where element goes & 1's everywhere else.
 
     uint64_t masked_reg =
         reg_data & mask; // Take original reg value & zero out 'element' bits
@@ -12307,10 +12262,10 @@
   return true;
 }
 
-// A8.6.391 VST1 (multiple single elements)
-// Vector Store (multiple single elements) stores elements to memory from one,
-// two, three, or four registers, without
-// interleaving.  Every element of each register is stored.
+// A8.6.391 VST1 (multiple single elements) Vector Store (multiple single
+// elements) stores elements to memory from one, two, three, or four
+// registers, without interleaving.  Every element of each register is
+// stored.
 bool EmulateInstructionARM::EmulateVST1Multiple(const uint32_t opcode,
                                                 ARMEncoding encoding) {
 #if 0
@@ -12376,7 +12331,8 @@
       else
         alignment = 4 << align;
 
-      // ebytes = 1 << UInt(size); esize = 8 * ebytes; elements = 8 DIV ebytes;
+      // ebytes = 1 << UInt(size); esize = 8 * ebytes; elements = 8 DIV
+      // ebytes;
       ebytes = 1 << Bits32(opcode, 7, 6);
       esize = 8 * ebytes;
       elements = 8 / ebytes;
@@ -12417,7 +12373,8 @@
       return false;
 
     EmulateInstruction::Context context;
-    // if wback then R[n] = R[n] + (if register_index then R[m] else 8*regs);
+    // if wback then R[n] = R[n] + (if register_index then R[m] else
+    // 8*regs);
     if (wback) {
       uint32_t Rm = ReadCoreReg(m, &success);
       if (!success)
@@ -12465,8 +12422,8 @@
   return true;
 }
 
-// A8.6.392 VST1 (single element from one lane)
-// This instruction stores one element to memory from one element of a register.
+// A8.6.392 VST1 (single element from one lane) This instruction stores
+// one element to memory from one element of a register.
 bool EmulateInstructionARM::EmulateVST1Single(const uint32_t opcode,
                                               ARMEncoding encoding) {
 #if 0
@@ -12506,7 +12463,8 @@
         // if index_align<0> != '0' then UNDEFINED;
         if (BitIsClear(index_align, 0))
           return false;
-        // ebytes = 1; esize = 8; index = UInt(index_align<3:1>); alignment = 1;
+        // ebytes = 1; esize = 8; index = UInt(index_align<3:1>);
+        // alignment = 1;
         ebytes = 1;
         esize = 8;
         index = Bits32(index_align, 3, 1);
@@ -12557,8 +12515,8 @@
       n = Bits32(opcode, 19, 16);
       m = Bits32(opcode, 3, 0);
 
-      // wback = (m != 15); register_index = (m != 15 && m != 13);  if n == 15
-      // then UNPREDICTABLE;
+      // wback = (m != 15); register_index = (m != 15 && m != 13);  if n
+      // == 15 then UNPREDICTABLE;
       wback = (m != 15);
       register_index = ((m != 15) && (m != 13));
 
@@ -12584,7 +12542,8 @@
       return false;
 
     EmulateInstruction::Context context;
-    // if wback then R[n] = R[n] + (if register_index then R[m] else ebytes);
+    // if wback then R[n] = R[n] + (if register_index then R[m] else
+    // ebytes);
     if (wback) {
       uint32_t Rm = ReadCoreReg(m, &success);
       if (!success)
@@ -12624,9 +12583,8 @@
   return true;
 }
 
-// A8.6.309 VLD1 (single element to all lanes)
-// This instruction loads one element from memory into every element of one or
-// two vectors.
+// A8.6.309 VLD1 (single element to all lanes) This instruction loads one
+// element from memory into every element of one or two vectors.
 bool EmulateInstructionARM::EmulateVLD1SingleAll(const uint32_t opcode,
                                                  const ARMEncoding encoding) {
 #if 0
@@ -12660,8 +12618,8 @@
       if ((size == 3) || ((size == 0) && BitIsSet(opcode, 4)))
         return false;
 
-      // ebytes = 1 << UInt(size); elements = 8 DIV ebytes; regs = if T == '0'
-      // then 1 else 2;
+      // ebytes = 1 << UInt(size); elements = 8 DIV ebytes; regs = if T ==
+      // '0' then 1 else 2;
       ebytes = 1 << size;
       elements = 8 / ebytes;
       if (BitIsClear(opcode, 5))
@@ -12710,7 +12668,8 @@
       return false;
 
     EmulateInstruction::Context context;
-    // if wback then R[n] = R[n] + (if register_index then R[m] else ebytes);
+    // if wback then R[n] = R[n] + (if register_index then R[m] else
+    // ebytes);
     if (wback) {
       uint32_t Rm = ReadCoreReg(m, &success);
       if (!success)
@@ -12754,11 +12713,10 @@
   return true;
 }
 
-// B6.2.13 SUBS PC, LR and related instructions
-// The SUBS PC, LR, #<const? instruction provides an exception return without
-// the use of the stack.  It subtracts the
-// immediate constant from the LR, branches to the resulting address, and also
-// copies the SPSR to the CPSR.
+// B6.2.13 SUBS PC, LR and related instructions The SUBS PC, LR, #<const?
+// instruction provides an exception return without the use of the stack.
+// It subtracts the immediate constant from the LR, branches to the
+// resulting address, and also copies the SPSR to the CPSR.
 bool EmulateInstructionARM::EmulateSUBSPcLrEtc(const uint32_t opcode,
                                                const ARMEncoding encoding) {
 #if 0
@@ -12797,8 +12755,8 @@
 
     switch (encoding) {
     case eEncodingT1:
-      // if CurrentInstrSet() == InstrSet_ThumbEE then UNPREDICTABLE
-      // n = 14; imm32 = ZeroExtend(imm8, 32); register_form = FALSE; opcode =
+      // if CurrentInstrSet() == InstrSet_ThumbEE then UNPREDICTABLE n =
+      // 14; imm32 = ZeroExtend(imm8, 32); register_form = FALSE; opcode =
       // '0010'; // = SUB
       n = 14;
       imm32 = Bits32(opcode, 7, 0);
@@ -12835,8 +12793,8 @@
       return false;
     }
 
-    // operand2 = if register_form then Shift(R[m], shift_t, shift_n, APSR.C)
-    // else imm32;
+    // operand2 = if register_form then Shift(R[m], shift_t, shift_n,
+    // APSR.C) else imm32;
     uint32_t operand2;
     if (register_form) {
       uint32_t Rm = ReadCoreReg(m, &success);
@@ -12889,12 +12847,14 @@
       break;
 
     case 6: // when '0110'
-      // (result, -, -) = AddWithCarry(R[n], NOT(operand2), APSR.C); // SBC
+      // (result, -, -) = AddWithCarry(R[n], NOT(operand2), APSR.C); //
+      // SBC
       result = AddWithCarry(Rn, ~(operand2), APSR_C);
       break;
 
     case 7: // when '0111'
-      // (result, -, -) = AddWithCarry(NOT(R[n]), operand2, APSR.C); // RSC
+      // (result, -, -) = AddWithCarry(NOT(R[n]), operand2, APSR.C); //
+      // RSC
       result = AddWithCarry(~(Rn), operand2, APSR_C);
       break;
 
@@ -12923,9 +12883,8 @@
     }
     // CPSRWriteByInstr(SPSR[], '1111', TRUE);
 
-    // For now, in emulation mode, we don't have access to the SPSR, so we will
-    // use the CPSR instead, and hope for
-    // the best.
+    // For now, in emulation mode, we don't have access to the SPSR, so we
+    // will use the CPSR instead, and hope for the best.
     uint32_t spsr =
         ReadRegisterUnsigned(eRegisterKindDWARF, dwarf_cpsr, 0, &success);
     if (!success)
@@ -13010,8 +12969,8 @@
       //----------------------------------------------------------------------
       // Branch instructions
       //----------------------------------------------------------------------
-      // To resolve ambiguity, "blx <label>" should come before "b #imm24" and
-      // "bl <label>".
+      // To resolve ambiguity, "blx <label>" should come before "b #imm24"
+      // and "bl <label>".
       {0xfe000000, 0xfa000000, ARMV5_ABOVE, eEncodingA2, No_VFP, eSize32,
        &EmulateInstructionARM::EmulateBLXImmediate, "blx <label>"},
       {0x0f000000, 0x0a000000, ARMvAll, eEncodingA1, No_VFP, eSize32,
@@ -13354,8 +13313,8 @@
       // copy the stack pointer to r7
       {0xffffffff, 0x0000466f, ARMvAll, eEncodingT1, No_VFP, eSize16,
        &EmulateInstructionARM::EmulateMOVRdSP, "mov r7, sp"},
-      // move from high register to low register (comes after "mov r7, sp" to
-      // resolve ambiguity)
+      // move from high register to low register (comes after "mov r7, sp"
+      // to resolve ambiguity)
       {0xffffffc0, 0x00004640, ARMvAll, eEncodingT1, No_VFP, eSize16,
        &EmulateInstructionARM::EmulateMOVLowHigh, "mov r0-r7, r8-r15"},
 
@@ -13476,8 +13435,8 @@
       // add (register)
       {0xfffffe00, 0x00001800, ARMvAll, eEncodingT1, No_VFP, eSize16,
        &EmulateInstructionARM::EmulateADDReg, "adds|add<c> <Rd>, <Rn>, <Rm>"},
-      // Make sure "add sp, <Rm>" comes before this instruction, so there's no
-      // ambiguity decoding the two.
+      // Make sure "add sp, <Rm>" comes before this instruction, so
+      // there's no ambiguity decoding the two.
       {0xffffff00, 0x00004400, ARMvAll, eEncodingT2, No_VFP, eSize16,
        &EmulateInstructionARM::EmulateADDReg, "add<c> <Rdn>, <Rm>"},
       // adr
@@ -13692,9 +13651,9 @@
        &EmulateInstructionARM::EmulateSUBSPcLrEtc, "SUBS<c> PC, LR, #<imm8>"},
 
       //----------------------------------------------------------------------
-      // RFE instructions  *** IMPORTANT *** THESE MUST BE LISTED **BEFORE** THE
-      // LDM.. Instructions in this table;
-      // otherwise the wrong instructions will be selected.
+      // RFE instructions  *** IMPORTANT *** THESE MUST BE LISTED
+      // **BEFORE** THE LDM.. Instructions in this table; otherwise the
+      // wrong instructions will be selected.
       //----------------------------------------------------------------------
 
       {0xffd0ffff, 0xe810c000, ARMV6T2_ABOVE, eEncodingT1, No_VFP, eSize32,
@@ -13998,9 +13957,8 @@
       }
 
       if (!m_ignore_conditions) {
-        // If we are not ignoreing the conditions then init the it session from
-        // the current
-        // value of cpsr.
+        // If we are not ignoreing the conditions then init the it session
+        // from the current value of cpsr.
         uint32_t it = (Bits32(m_opcode_cpsr, 15, 10) << 2) |
                       Bits32(m_opcode_cpsr, 26, 25);
         if (it != 0)
@@ -14018,10 +13976,9 @@
 uint32_t EmulateInstructionARM::ArchVersion() { return m_arm_isa; }
 
 bool EmulateInstructionARM::ConditionPassed(const uint32_t opcode) {
-  // If we are ignoring conditions, then always return true.
-  // this allows us to iterate over disassembly code and still
-  // emulate an instruction even if we don't have all the right
-  // bits set in the CPSR register...
+  // If we are ignoring conditions, then always return true. this allows
+  // us to iterate over disassembly code and still emulate an instruction
+  // even if we don't have all the right bits set in the CPSR register...
   if (m_ignore_conditions)
     return true;
 
@@ -14100,8 +14057,8 @@
     return UnsignedBits(opcode, 31, 28);
 
   case eModeThumb:
-    // For T1 and T3 encodings of the Branch instruction, it returns the 4-bit
-    // 'cond' field of the encoding.
+    // For T1 and T3 encodings of the Branch instruction, it returns the
+    // 4-bit 'cond' field of the encoding.
     {
       const uint32_t byte_size = m_opcode.GetByteSize();
       if (byte_size == 2) {
@@ -14220,13 +14177,13 @@
   return true;
 }
 
-// As a side effect, BXWritePC sets context.arg2 to eModeARM or eModeThumb by
-// inspecting addr.
+// As a side effect, BXWritePC sets context.arg2 to eModeARM or eModeThumb
+// by inspecting addr.
 bool EmulateInstructionARM::BXWritePC(Context &context, uint32_t addr) {
   addr_t target;
-  // If the CPSR is changed due to switching between ARM and Thumb ISETSTATE,
-  // we want to record it and issue a WriteRegister callback so the clients
-  // can track the mode changes accordingly.
+  // If the CPSR is changed due to switching between ARM and Thumb
+  // ISETSTATE, we want to record it and issue a WriteRegister callback so
+  // the clients can track the mode changes accordingly.
   bool cpsr_changed = false;
 
   if (BitIsSet(addr, 0)) {
@@ -14280,9 +14237,9 @@
   return m_opcode_mode;
 }
 
-// Set the 'T' bit of our CPSR.  The m_opcode_mode gets updated when the next
-// ReadInstruction() is performed.  This function has a side effect of updating
-// the m_new_inst_cpsr member variable if necessary.
+// Set the 'T' bit of our CPSR.  The m_opcode_mode gets updated when the
+// next ReadInstruction() is performed.  This function has a side effect
+// of updating the m_new_inst_cpsr member variable if necessary.
 bool EmulateInstructionARM::SelectInstrSet(Mode arm_or_thumb) {
   m_new_inst_cpsr = m_opcode_cpsr;
   switch (arm_or_thumb) {
@@ -14300,16 +14257,18 @@
   return true;
 }
 
-// This function returns TRUE if the processor currently provides support for
-// unaligned memory accesses, or FALSE otherwise. This is always TRUE in ARMv7,
-// controllable by the SCTLR.U bit in ARMv6, and always FALSE before ARMv6.
+// This function returns TRUE if the processor currently provides support
+// for unaligned memory accesses, or FALSE otherwise. This is always TRUE
+// in ARMv7, controllable by the SCTLR.U bit in ARMv6, and always FALSE
+// before ARMv6.
 bool EmulateInstructionARM::UnalignedSupport() {
   return (ArchVersion() >= ARMv7);
 }
 
-// The main addition and subtraction instructions can produce status information
-// about both unsigned carry and signed overflow conditions.  This status
-// information can be used to synthesize multi-word additions and subtractions.
+// The main addition and subtraction instructions can produce status
+// information about both unsigned carry and signed overflow conditions.
+// This status information can be used to synthesize multi-word additions
+// and subtractions.
 EmulateInstructionARM::AddWithCarryResult
 EmulateInstructionARM::AddWithCarry(uint32_t x, uint32_t y, uint8_t carry_in) {
   uint32_t result;
@@ -14363,10 +14322,9 @@
   // Read our register.
   uint32_t val = ReadRegisterUnsigned(reg_kind, reg_num, 0, success);
 
-  // When executing an ARM instruction , PC reads as the address of the current
-  // instruction plus 8.
-  // When executing a Thumb instruction , PC reads as the address of the current
-  // instruction plus 4.
+  // When executing an ARM instruction , PC reads as the address of the
+  // current instruction plus 8. When executing a Thumb instruction , PC
+  // reads as the address of the current instruction plus 4.
   if (num == 15) {
     if (CurrentInstrSet() == eModeARM)
       val += 8;
@@ -14380,8 +14338,8 @@
 // Write the result to the ARM core register Rd, and optionally update the
 // condition flags based on the result.
 //
-// This helper method tries to encapsulate the following pseudocode from the
-// ARM Architecture Reference Manual:
+// This helper method tries to encapsulate the following pseudocode from
+// the ARM Architecture Reference Manual:
 //
 // if d == 15 then         // Can only occur for encoding A1
 //     ALUWritePC(result); // setflags is always FALSE here
@@ -14393,8 +14351,8 @@
 //         APSR.C = carry;
 //         // APSR.V unchanged
 //
-// In the above case, the API client does not pass in the overflow arg, which
-// defaults to ~0u.
+// In the above case, the API client does not pass in the overflow arg,
+// which defaults to ~0u.
 bool EmulateInstructionARM::WriteCoreRegOptionalFlags(
     Context &context, const uint32_t result, const uint32_t Rd, bool setflags,
     const uint32_t carry, const uint32_t overflow) {
@@ -14425,17 +14383,16 @@
   return true;
 }
 
-// This helper method tries to encapsulate the following pseudocode from the
-// ARM Architecture Reference Manual:
+// This helper method tries to encapsulate the following pseudocode from
+// the ARM Architecture Reference Manual:
 //
 // APSR.N = result<31>;
 // APSR.Z = IsZeroBit(result);
 // APSR.C = carry;
 // APSR.V = overflow
 //
-// Default arguments can be specified for carry and overflow parameters, which
-// means
-// not to update the respective flags.
+// Default arguments can be specified for carry and overflow parameters,
+// which means not to update the respective flags.
 bool EmulateInstructionARM::WriteFlags(Context &context, const uint32_t result,
                                        const uint32_t carry,
                                        const uint32_t overflow) {
@@ -14495,9 +14452,8 @@
       return false;
   }
 
-  // Advance the ITSTATE bits to their values for the next instruction if we
-  // haven't just executed
-  // an IT instruction what initialized it.
+  // Advance the ITSTATE bits to their values for the next instruction if
+  // we haven't just executed an IT instruction what initialized it.
   if (m_opcode_mode == eModeThumb && m_it_session.InITBlock() &&
       (opcode_data == nullptr ||
        opcode_data->callback != &EmulateInstructionARM::EmulateIT))
@@ -14618,7 +14574,8 @@
 //
 //
 // const char *
-// EmulateInstructionARM::GetRegisterName (uint32_t reg_kind, uint32_t reg_num)
+// EmulateInstructionARM::GetRegisterName (uint32_t reg_kind, uint32_t
+// reg_num)
 //{
 //    if (reg_kind == eRegisterKindGeneric)
 //    {
Index: source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp
===================================================================
--- source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp
+++ source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp
@@ -112,8 +112,8 @@
   switch (which) {
   case EmulateInstructionARM64::Unpredictable_WBOVERLAP:
   case EmulateInstructionARM64::Unpredictable_LDPOVERLAP:
-    // TODO: don't know what to really do here? Pseudo code says:
-    // set result to one of above Constraint behaviours or UNDEFINED
+    // TODO: don't know what to really do here? Pseudo code says: set
+    // result to one of above Constraint behaviours or UNDEFINED
     break;
   }
   return result;
@@ -420,7 +420,8 @@
   if (opcode_data == NULL)
     return false;
 
-  // printf ("opcode template for 0x%8.8x: %s\n", opcode, opcode_data->name);
+  // printf ("opcode template for 0x%8.8x: %s\n", opcode,
+  // opcode_data->name);
   const bool auto_advance_pc =
       evaluate_options & eEmulateInstructionOptionAutoAdvancePC;
   m_ignore_conditions =
@@ -498,16 +499,16 @@
 
 bool EmulateInstructionARM64::UsingAArch32() {
   bool aarch32 = m_opcode_pstate.RW == 1;
-  // if !HaveAnyAArch32() then assert !aarch32;
-  // if HighestELUsingAArch32() then assert aarch32;
+  // if !HaveAnyAArch32() then assert !aarch32; if HighestELUsingAArch32()
+  // then assert aarch32;
   return aarch32;
 }
 
 bool EmulateInstructionARM64::BranchTo(const Context &context, uint32_t N,
                                        addr_t target) {
 #if 0
-    // Set program counter to a new address, with a branch reason hint
-    // for possible use by hardware fetching the next instruction.
+    // Set program counter to a new address, with a branch reason hint for
+    // possible use by hardware fetching the next instruction.
     BranchTo(bits(N) target, BranchType branch_type)
         Hint_Branch(branch_type);
         if N == 32 then
@@ -555,10 +556,9 @@
 }
 
 bool EmulateInstructionARM64::ConditionHolds(const uint32_t cond) {
-  // If we are ignoring conditions, then always return true.
-  // this allows us to iterate over disassembly code and still
-  // emulate an instruction even if we don't have all the right
-  // bits set in the CPSR register...
+  // If we are ignoring conditions, then always return true. this allows
+  // us to iterate over disassembly code and still emulate an instruction
+  // even if we don't have all the right bits set in the CPSR register...
   if (m_ignore_conditions)
     return true;
 
@@ -599,10 +599,8 @@
 bool EmulateInstructionARM64::EmulateADDSUBImm(const uint32_t opcode) {
   // integer d = UInt(Rd);
   // integer n = UInt(Rn);
-  // integer datasize = if sf == 1 then 64 else 32;
-  // boolean sub_op = (op == 1);
-  // boolean setflags = (S == 1);
-  // bits(datasize) imm;
+  // integer datasize = if sf == 1 then 64 else 32; boolean sub_op = (op
+  // == 1); boolean setflags = (S == 1); bits(datasize) imm;
   //
   // case shift of
   //     when '00' imm = ZeroExtend(imm12, datasize);
@@ -612,9 +610,7 @@
   //
   // bits(datasize) result;
   // bits(datasize) operand1 = if n == 31 then SP[] else X[n];
-  // bits(datasize) operand2 = imm;
-  // bits(4) nzcv;
-  // bit carry_in;
+  // bits(datasize) operand2 = imm; bits(4) nzcv; bit carry_in;
   //
   // if sub_op then
   //     operand2 = NOT(operand2);
@@ -690,8 +686,8 @@
     context.SetRegisterPlusOffset(reg_info_Rn, imm);
 
   if (n == GetFramePointerRegisterNumber() && d == gpr_sp_arm64 && !setflags) {
-    // 'mov sp, fp' - common epilogue instruction, CFA is now in terms
-    // of the stack pointer, instead of frame pointer.
+    // 'mov sp, fp' - common epilogue instruction, CFA is now in terms of
+    // the stack pointer, instead of frame pointer.
     context.type = EmulateInstruction::eContextRestoreStackPointer;
   } else if ((n == gpr_sp_arm64 || n == GetFramePointerRegisterNumber()) &&
              d == gpr_sp_arm64 && !setflags) {
Index: source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp
===================================================================
--- source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp
+++ source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp
@@ -1205,13 +1205,10 @@
   dst = m_reg_info->getEncodingValue(insn.getOperand(0).getReg());
   src = m_reg_info->getEncodingValue(insn.getOperand(1).getReg());
 
-  // If immediate value is greater then 2^16 - 1 then clang generate
-  // LUI, ADDIU, SUBU instructions in prolog.
-  // Example
-  // lui    $1, 0x2
-  // addiu $1, $1, -0x5920
-  // subu  $sp, $sp, $1
-  // In this case, ADDIU dst and src will be same and not equal to sp
+  // If immediate value is greater then 2^16 - 1 then clang generate LUI,
+  // ADDIU, SUBU instructions in prolog. Example lui    $1, 0x2 addiu $1,
+  // $1, -0x5920 subu  $sp, $sp, $1 In this case, ADDIU dst and src will
+  // be same and not equal to sp
   if (dst == src) {
     Context context;
 
@@ -1545,8 +1542,8 @@
   address = address + imm5;
 
   // We use bad_vaddr_context to store base address which is used by H/W
-  // watchpoint
-  // Set the bad_vaddr register with base address used in the instruction
+  // watchpoint Set the bad_vaddr register with base address used in the
+  // instruction
   bad_vaddr_context.type = eContextInvalid;
   WriteRegisterUnsigned(bad_vaddr_context, eRegisterKindDWARF, dwarf_bad_mips,
                         address);
@@ -1594,8 +1591,8 @@
   base =
       m_reg_info->getEncodingValue(insn.getOperand(num_operands - 2).getReg());
 
-  // We are looking for sp based stores so if base is not a stack pointer then
-  // don't proceed.
+  // We are looking for sp based stores so if base is not a stack pointer
+  // then don't proceed.
   if (base != dwarf_sp_mips)
     return false;
 
@@ -1682,8 +1679,8 @@
   base_address = base_address + imm5;
 
   // We use bad_vaddr_context to store base address which is used by H/W
-  // watchpoint
-  // Set the bad_vaddr register with base address used in the instruction
+  // watchpoint Set the bad_vaddr register with base address used in the
+  // instruction
   bad_vaddr_context.type = eContextInvalid;
   WriteRegisterUnsigned(bad_vaddr_context, eRegisterKindDWARF, dwarf_bad_mips,
                         base_address);
@@ -1727,8 +1724,8 @@
   base =
       m_reg_info->getEncodingValue(insn.getOperand(num_operands - 2).getReg());
 
-  // We are looking for sp based loads so if base is not a stack pointer then
-  // don't proceed.
+  // We are looking for sp based loads so if base is not a stack pointer
+  // then don't proceed.
   if (base != dwarf_sp_mips)
     return false;
 
Index: source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp
===================================================================
--- source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp
+++ source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp
@@ -1091,13 +1091,10 @@
   dst = m_reg_info->getEncodingValue(insn.getOperand(0).getReg());
   src = m_reg_info->getEncodingValue(insn.getOperand(1).getReg());
 
-  // If immediate is greater than 2^16 - 1 then clang generate
-  // LUI, (D)ADDIU,(D)SUBU instructions in prolog.
-  // Example
-  // lui    $1, 0x2
-  // daddiu $1, $1, -0x5920
-  // dsubu  $sp, $sp, $1
-  // In this case, (D)ADDIU dst and src will be same and not equal to sp
+  // If immediate is greater than 2^16 - 1 then clang generate LUI,
+  // (D)ADDIU,(D)SUBU instructions in prolog. Example lui    $1, 0x2
+  // daddiu $1, $1, -0x5920 dsubu  $sp, $sp, $1 In this case, (D)ADDIU dst
+  // and src will be same and not equal to sp
   if (dst == src) {
     Context context;
 
Index: source/Plugins/Instruction/PPC64/EmulateInstructionPPC64.cpp
===================================================================
--- source/Plugins/Instruction/PPC64/EmulateInstructionPPC64.cpp
+++ source/Plugins/Instruction/PPC64/EmulateInstructionPPC64.cpp
@@ -248,8 +248,8 @@
 
   int32_t ids = llvm::SignExtend32<16>(ds << 2);
 
-  // For now, tracking only loads from 0(r1) to r1
-  // (0(r1) is the ABI defined location to save previous SP)
+  // For now, tracking only loads from 0(r1) to r1 (0(r1) is the ABI
+  // defined location to save previous SP)
   if (ra != gpr_r1_ppc64le || rt != gpr_r1_ppc64le || ids != 0)
     return false;
 
@@ -279,7 +279,8 @@
   // For now, tracking only stores to r1
   if (ra != gpr_r1_ppc64le)
     return false;
-  // ... and only stores of SP, FP and LR (moved into r0 by a previous mfspr)
+  // ... and only stores of SP, FP and LR (moved into r0 by a previous
+  // mfspr)
   if (rs != gpr_r1_ppc64le && rs != gpr_r31_ppc64le && rs != gpr_r30_ppc64le &&
       rs != gpr_r0_ppc64le)
     return false;
@@ -294,8 +295,8 @@
   LLDB_LOG(log, "EmulateSTD: {0:X+8}: std{1} r{2}, {3}(r{4})", m_addr,
            u ? "u" : "", rs, ids, ra);
 
-  // Make sure that r0 is really holding LR value
-  // (this won't catch unlikely cases, such as r0 being overwritten after mfspr)
+  // Make sure that r0 is really holding LR value (this won't catch
+  // unlikely cases, such as r0 being overwritten after mfspr)
   uint32_t rs_num = rs;
   if (rs == gpr_r0_ppc64le) {
     uint64_t lr =
@@ -342,7 +343,8 @@
   uint32_t ra = Bits32(opcode, 20, 16);
   uint32_t rb = Bits32(opcode, 15, 11);
 
-  // to be safe, process only the known 'mr r31/r30, r1' prologue instructions
+  // to be safe, process only the known 'mr r31/r30, r1' prologue
+  // instructions
   if (m_fp != LLDB_INVALID_REGNUM || rs != rb ||
       (ra != gpr_r30_ppc64le && ra != gpr_r31_ppc64le) || rb != gpr_r1_ppc64le)
     return false;
Index: source/Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.cpp
===================================================================
--- source/Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.cpp
+++ source/Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.cpp
@@ -125,7 +125,8 @@
     if (!responsible_frame)
       responsible_frame = frame;
 
-    // First frame in stacktrace should point to a real PC, not return address.
+    // First frame in stacktrace should point to a real PC, not return
+    // address.
     if (I != 0 && trace->GetSize() == 0) {
       addr.Slide(-1);
     }
Index: source/Plugins/InstrumentationRuntime/TSan/TSanRuntime.cpp
===================================================================
--- source/Plugins/InstrumentationRuntime/TSan/TSanRuntime.cpp
+++ source/Plugins/InstrumentationRuntime/TSan/TSanRuntime.cpp
@@ -280,11 +280,10 @@
         if (lldb_thread) {
           lldb_user_id = lldb_thread->GetIndexID();
         } else {
-          // This isn't a live thread anymore.  Ask process to assign a new
-          // Index ID (or return an old one if we've already seen this
-          // thread_os_id).
-          // It will also make sure that no new threads are assigned this Index
-          // ID.
+          // This isn't a live thread anymore.  Ask process to assign a
+          // new Index ID (or return an old one if we've already seen this
+          // thread_os_id). It will also make sure that no new threads are
+          // assigned this Index ID.
           lldb_user_id = process_sp->AssignIndexIDToThread(thread_os_id);
         }
 
@@ -1039,8 +1038,8 @@
         ThreadSP new_thread_sp(history_thread);
         new_thread_sp->SetName(GenerateThreadName(path, o, info).c_str());
 
-        // Save this in the Process' ExtendedThreadList so a strong pointer
-        // retains the object
+        // Save this in the Process' ExtendedThreadList so a strong
+        // pointer retains the object
         process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
         threads->AddThread(new_thread_sp);
 
Index: source/Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.cpp
===================================================================
--- source/Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.cpp
+++ source/Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.cpp
@@ -247,7 +247,8 @@
   return symbol != nullptr;
 }
 
-// FIXME: Factor out all the logic we have in common with the {a,t}san plugins.
+// FIXME: Factor out all the logic we have in common with the {a,t}san
+// plugins.
 void UndefinedBehaviorSanitizerRuntime::Activate() {
   if (IsActive())
     return;
Index: source/Plugins/Language/CPlusPlus/BlockPointer.cpp
===================================================================
--- source/Plugins/Language/CPlusPlus/BlockPointer.cpp
+++ source/Plugins/Language/CPlusPlus/BlockPointer.cpp
@@ -147,9 +147,8 @@
     return child_sp;
   }
 
-  // return true if this object is now safe to use forever without
-  // ever updating again; the typical (and tested) answer here is
-  // 'false'
+  // return true if this object is now safe to use forever without ever
+  // updating again; the typical (and tested) answer here is 'false'
   bool Update() override { return false; }
 
   // maybe return false if the block pointer is, say, null
Index: source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
===================================================================
--- source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
+++ source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
@@ -120,10 +120,9 @@
 
 static bool IsTrivialBasename(const llvm::StringRef &basename) {
   // Check that the basename matches with the following regular expression
-  // "^~?([A-Za-z_][A-Za-z_0-9]*)$"
-  // We are using a hand written implementation because it is significantly more
-  // efficient then
-  // using the general purpose regular expression library.
+  // "^~?([A-Za-z_][A-Za-z_0-9]*)$" We are using a hand written
+  // implementation because it is significantly more efficient then using
+  // the general purpose regular expression library.
   size_t idx = 0;
   if (basename.size() > 0 && basename[0] == '~')
     idx = 1;
@@ -151,11 +150,10 @@
 }
 
 bool CPlusPlusLanguage::MethodName::TrySimplifiedParse() {
-  // This method tries to parse simple method definitions
-  // which are presumably most comman in user programs.
-  // Definitions that can be parsed by this function don't have return types
-  // and templates in the name.
-  // A::B::C::fun(std::vector<T> &) const
+  // This method tries to parse simple method definitions which are
+  // presumably most comman in user programs. Definitions that can be
+  // parsed by this function don't have return types and templates in the
+  // name. A::B::C::fun(std::vector<T> &) const
   size_t arg_start, arg_end;
   llvm::StringRef full(m_full.GetCString());
   llvm::StringRef parens("()", 2);
@@ -181,8 +179,9 @@
     if (IsTrivialBasename(m_basename)) {
       return true;
     } else {
-      // The C++ basename doesn't match our regular expressions so this can't
-      // be a valid C++ method, clear everything out and indicate an error
+      // The C++ basename doesn't match our regular expressions so this
+      // can't be a valid C++ method, clear everything out and indicate an
+      // error
       m_context = llvm::StringRef();
       m_basename = llvm::StringRef();
       m_arguments = llvm::StringRef();
@@ -285,8 +284,8 @@
   const size_t max_len =
       mangled.size() + mangled.count(search) * replace.size() + 1;
 
-  // Make a temporary buffer to fix up the mangled parameter types and copy the
-  // original there
+  // Make a temporary buffer to fix up the mangled parameter types and
+  // copy the original there
   std::string output_buf;
   output_buf.reserve(max_len);
   output_buf.insert(0, mangled.str());
@@ -299,8 +298,8 @@
     // Check whether we've found a substitutee
     llvm::StringRef s(parsee);
     if (s.startswith(search)) {
-      // account for the case where a replacement is of a different length to
-      // the original
+      // account for the case where a replacement is of a different length
+      // to the original
       replaced_offset += replace.size() - search.size();
 
       ptrdiff_t replace_idx = (mangled.size() - s.size()) + replaced_offset;
@@ -309,8 +308,8 @@
     }
   };
 
-  // FastDemangle will call our hook for each instance of a primitive type,
-  // allowing us to perform substitution
+  // FastDemangle will call our hook for each instance of a primitive
+  // type, allowing us to perform substitution
   const char *const demangled =
       FastDemangle(mangled.str().c_str(), mangled.size(), swap_parms_hook);
 
@@ -331,8 +330,8 @@
   /// is filled with a best-guess, non-exhaustive set of different manglings
   /// for the given name.
 
-  // Maybe we're looking for a const symbol but the debug info told us it was
-  // non-const...
+  // Maybe we're looking for a const symbol but the debug info told us it
+  // was non-const...
   if (!strncmp(mangled_name.GetCString(), "_ZN", 3) &&
       strncmp(mangled_name.GetCString(), "_ZNK", 4)) {
     std::string fixed_scratch("_ZNK");
@@ -340,7 +339,8 @@
     alternates.insert(ConstString(fixed_scratch));
   }
 
-  // Maybe we're looking for a static symbol but we thought it was global...
+  // Maybe we're looking for a static symbol but we thought it was
+  // global...
   if (!strncmp(mangled_name.GetCString(), "_Z", 2) &&
       strncmp(mangled_name.GetCString(), "_ZL", 3)) {
     std::string fixed_scratch("_ZL");
@@ -348,21 +348,23 @@
     alternates.insert(ConstString(fixed_scratch));
   }
 
-  // `char` is implementation defined as either `signed` or `unsigned`.  As a
-  // result a char parameter has 3 possible manglings: 'c'-char, 'a'-signed
-  // char, 'h'-unsigned char.  If we're looking for symbols with a signed char
-  // parameter, try finding matches which have the general case 'c'.
+  // `char` is implementation defined as either `signed` or `unsigned`.
+  // As a result a char parameter has 3 possible manglings: 'c'-char,
+  // 'a'-signed char, 'h'-unsigned char.  If we're looking for symbols
+  // with a signed char parameter, try finding matches which have the
+  // general case 'c'.
   if (ConstString char_fixup =
           SubsPrimitiveParmItanium(mangled_name.GetStringRef(), "a", "c"))
     alternates.insert(char_fixup);
 
-  // long long parameter mangling 'x', may actually just be a long 'l' argument
+  // long long parameter mangling 'x', may actually just be a long 'l'
+  // argument
   if (ConstString long_fixup =
           SubsPrimitiveParmItanium(mangled_name.GetStringRef(), "x", "l"))
     alternates.insert(long_fixup);
 
-  // unsigned long long parameter mangling 'y', may actually just be unsigned
-  // long 'm' argument
+  // unsigned long long parameter mangling 'y', may actually just be
+  // unsigned long 'm' argument
   if (ConstString ulong_fixup =
           SubsPrimitiveParmItanium(mangled_name.GetStringRef(), "y", "m"))
     alternates.insert(ulong_fixup);
@@ -800,8 +802,8 @@
       .SetHideItemNames(false);
 
 #ifndef LLDB_DISABLE_PYTHON
-  // FIXME because of a bug in the FormattersContainer we need to add a summary
-  // for both X* and const X* (<rdar://problem/12717717>)
+  // FIXME because of a bug in the FormattersContainer we need to add a
+  // summary for both X* and const X* (<rdar://problem/12717717>)
   AddCXXSummary(
       cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider,
       "char16_t * summary provider", ConstString("char16_t *"), string_flags);
Index: source/Plugins/Language/CPlusPlus/CPlusPlusNameParser.cpp
===================================================================
--- source/Plugins/Language/CPlusPlus/CPlusPlusNameParser.cpp
+++ source/Plugins/Language/CPlusPlus/CPlusPlusNameParser.cpp
@@ -40,8 +40,8 @@
   if (result)
     return result;
 
-  // Finally try to parse the name as a function with non-function return type
-  // e.g. int main(int, char*[])
+  // Finally try to parse the name as a function with non-function return
+  // type e.g. int main(int, char*[])
   result = ParseFunctionImpl(true);
   if (HasMoreTokens())
     return None;
@@ -182,11 +182,11 @@
     return false;
   Advance();
 
-  // Consuming template arguments is a bit trickier than consuming function
-  // arguments, because '<' '>' brackets are not always trivially balanced.
-  // In some rare cases tokens '<' and '>' can appear inside template arguments
-  // as arithmetic or shift operators not as template brackets.
-  // Examples: std::enable_if<(10u)<(64), bool>
+  // Consuming template arguments is a bit trickier than consuming
+  // function arguments, because '<' '>' brackets are not always trivially
+  // balanced. In some rare cases tokens '<' and '>' can appear inside
+  // template arguments as arithmetic or shift operators not as template
+  // brackets. Examples: std::enable_if<(10u)<(64), bool>
   //           f<A<operator<(X,Y)::Subclass>>
   // Good thing that compiler makes sure that really ambiguous cases of
   // '>' usage should be enclosed within '()' brackets.
@@ -208,9 +208,10 @@
     case tok::less:
       // '<' is an attempt to open a subteamplte
       // check if parser is at the point where it's actually possible,
-      // otherwise it's just a part of an expression like 'sizeof(T)<(10)'.
-      // No need to do the same for '>' because compiler actually makes sure
-      // that '>' always surrounded by brackets to avoid ambiguity.
+      // otherwise it's just a part of an expression like
+      // 'sizeof(T)<(10)'. No need to do the same for '>' because compiler
+      // actually makes sure that '>' always surrounded by brackets to
+      // avoid ambiguity.
       if (can_open_template)
         ++template_counter;
       can_open_template = false;
@@ -388,9 +389,8 @@
 bool CPlusPlusNameParser::ConsumeBuiltinType() {
   bool result = false;
   bool continue_parsing = true;
-  // Built-in types can be made of a few keywords
-  // like 'unsigned long long int'. This function
-  // consumes all built-in type keywords without
+  // Built-in types can be made of a few keywords like 'unsigned long long
+  // int'. This function consumes all built-in type keywords without
   // checking if they make sense like 'unsigned char void'.
   while (continue_parsing && HasMoreTokens()) {
     switch (Peek().getKind()) {
Index: source/Plugins/Language/CPlusPlus/LibCxx.cpp
===================================================================
--- source/Plugins/Language/CPlusPlus/LibCxx.cpp
+++ source/Plugins/Language/CPlusPlus/LibCxx.cpp
@@ -123,12 +123,11 @@
   
   static ConstString g___i_("__i_");
   
-  // this must be a ValueObject* because it is a child of the ValueObject we are
-  // producing children for
-  // it if were a ValueObjectSP, we would end up with a loop (iterator ->
-  // synthetic -> child -> parent == iterator)
-  // and that would in turn leak memory by never allowing the ValueObjects to
-  // die and free their memory
+  // this must be a ValueObject* because it is a child of the ValueObject
+  // we are producing children for it if were a ValueObjectSP, we would
+  // end up with a loop (iterator -> synthetic -> child -> parent ==
+  // iterator) and that would in turn leak memory by never allowing the
+  // ValueObjects to die and free their memory
   m_pair_ptr = valobj_sp
                    ->GetValueForExpressionPath(
                        ".__i_.__ptr_->__value_", nullptr, nullptr,
@@ -378,15 +377,17 @@
                                        nullptr, nullptr, &valobj, false, false);
 }
 
-// the field layout in a libc++ string (cap, side, data or data, size, cap)
+// the field layout in a libc++ string (cap, side, data or data, size,
+// cap)
 enum LibcxxStringLayoutMode {
   eLibcxxStringLayoutModeCSD = 0,
   eLibcxxStringLayoutModeDSC = 1,
   eLibcxxStringLayoutModeInvalid = 0xffff
 };
 
-// this function abstracts away the layout and mode details of a libc++ string
-// and returns the address of the data and the size ready for callers to consume
+// this function abstracts away the layout and mode details of a libc++
+// string and returns the address of the data and the size ready for
+// callers to consume
 static bool ExtractLibcxxStringInfo(ValueObject &valobj,
                                     ValueObjectSP &location_sp,
                                     uint64_t &size) {
Index: source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp
===================================================================
--- source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp
+++ source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp
@@ -59,9 +59,8 @@
 
 lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
     ~LibcxxInitializerListSyntheticFrontEnd() {
-  // this needs to stay around because it's a child object who will follow its
-  // parent's life cycle
-  // delete m_start;
+  // this needs to stay around because it's a child object who will follow
+  // its parent's life cycle delete m_start;
 }
 
 size_t lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
Index: source/Plugins/Language/CPlusPlus/LibCxxList.cpp
===================================================================
--- source/Plugins/Language/CPlusPlus/LibCxxList.cpp
+++ source/Plugins/Language/CPlusPlus/LibCxxList.cpp
@@ -200,24 +200,23 @@
 bool AbstractListFrontEnd::HasLoop(size_t count) {
   if (!g_use_loop_detect)
     return false;
-  // don't bother checking for a loop if we won't actually need to jump nodes
+  // don't bother checking for a loop if we won't actually need to jump
+  // nodes
   if (m_count < 2)
     return false;
 
   if (m_loop_detected == 0) {
-    // This is the first time we are being run (after the last update). Set up
-    // the loop
-    // invariant for the first element.
+    // This is the first time we are being run (after the last update).
+    // Set up the loop invariant for the first element.
     m_slow_runner = ListEntry(m_head).next();
     m_fast_runner = m_slow_runner.next();
     m_loop_detected = 1;
   }
 
   // Loop invariant:
-  // Loop detection has been run over the first m_loop_detected elements. If
-  // m_slow_runner ==
-  // m_fast_runner then the loop has been detected after m_loop_detected
-  // elements.
+  // Loop detection has been run over the first m_loop_detected elements.
+  // If m_slow_runner == m_fast_runner then the loop has been detected
+  // after m_loop_detected elements.
   const size_t steps_to_run = std::min(count, m_count);
   while (m_loop_detected < steps_to_run && m_slow_runner && m_fast_runner &&
          m_slow_runner != m_fast_runner) {
@@ -284,8 +283,8 @@
   if (!current_sp)
     return nullptr;
 
-  // we need to copy current_sp into a new object otherwise we will end up with
-  // all items named __value_
+  // we need to copy current_sp into a new object otherwise we will end up
+  // with all items named __value_
   DataExtractor data;
   Status error;
   current_sp->GetData(data, error);
@@ -393,7 +392,8 @@
     if (!process_sp)
       return nullptr;
 
-    // if we grabbed the __next_ pointer, then the child is one pointer deep-er
+    // if we grabbed the __next_ pointer, then the child is one pointer
+    // deep-er
     lldb::addr_t addr = current_sp->GetParent()->GetPointerValue();
     addr = addr + 2 * process_sp->GetAddressByteSize();
     ExecutionContext exe_ctx(process_sp);
@@ -401,8 +401,8 @@
         CreateValueObjectFromAddress("__value_", addr, exe_ctx, m_element_type);
   }
 
-  // we need to copy current_sp into a new object otherwise we will end up with
-  // all items named __value_
+  // we need to copy current_sp into a new object otherwise we will end up
+  // with all items named __value_
   DataExtractor data;
   Status error;
   current_sp->GetData(data, error);
Index: source/Plugins/Language/CPlusPlus/LibCxxMap.cpp
===================================================================
--- source/Plugins/Language/CPlusPlus/LibCxxMap.cpp
+++ source/Plugins/Language/CPlusPlus/LibCxxMap.cpp
@@ -382,8 +382,9 @@
         return lldb::ValueObjectSP();
       }
     } else {
-      // because of the way our debug info is made, we need to read item 0 first
-      // so that we can cache information used to generate other elements
+      // because of the way our debug info is made, we need to read item 0
+      // first so that we can cache information used to generate other
+      // elements
       if (m_skip_size == UINT32_MAX)
         GetChildAtIndex(0);
       if (m_skip_size == UINT32_MAX) {
@@ -402,8 +403,8 @@
     return lldb::ValueObjectSP();
   }
   // at this point we have a valid
-  // we need to copy current_sp into a new object otherwise we will end up with
-  // all items named __value_
+  // we need to copy current_sp into a new object otherwise we will end up
+  // with all items named __value_
   DataExtractor data;
   Status error;
   iterated_sp->GetData(data, error);
Index: source/Plugins/Language/CPlusPlus/LibCxxVector.cpp
===================================================================
--- source/Plugins/Language/CPlusPlus/LibCxxVector.cpp
+++ source/Plugins/Language/CPlusPlus/LibCxxVector.cpp
@@ -81,10 +81,8 @@
 
 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
     ~LibcxxStdVectorSyntheticFrontEnd() {
-  // these need to stay around because they are child objects who will follow
-  // their parent's life cycle
-  // delete m_start;
-  // delete m_finish;
+  // these need to stay around because they are child objects who will
+  // follow their parent's life cycle delete m_start; delete m_finish;
 }
 
 size_t lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
Index: source/Plugins/Language/CPlusPlus/LibStdcppUniquePointer.cpp
===================================================================
--- source/Plugins/Language/CPlusPlus/LibStdcppUniquePointer.cpp
+++ source/Plugins/Language/CPlusPlus/LibStdcppUniquePointer.cpp
@@ -71,8 +71,8 @@
   ValueObjectSP obj_subchild_sp =
       obj_child_sp->GetChildMemberWithName(ConstString("_M_t"), true);
 
-  // if there is a _M_t subchild, the tuple is found in
-  // the obj_subchild_sp (for libstdc++ 6.0.23).
+  // if there is a _M_t subchild, the tuple is found in the
+  // obj_subchild_sp (for libstdc++ 6.0.23).
   if (obj_subchild_sp) {
     return obj_subchild_sp;
   }
Index: source/Plugins/Language/ObjC/Cocoa.cpp
===================================================================
--- source/Plugins/Language/ObjC/Cocoa.cpp
+++ source/Plugins/Language/ObjC/Cocoa.cpp
@@ -767,8 +767,8 @@
     return true;
   }
   // this snippet of code assumes that time_t == seconds since Jan-1-1970
-  // this is generally true and POSIXly happy, but might break if a library
-  // vendor decides to get creative
+  // this is generally true and POSIXly happy, but might break if a
+  // library vendor decides to get creative
   time_t epoch = GetOSXEpoch();
   epoch = epoch + (time_t)date_value;
   tm *tm_date = gmtime(&epoch);
@@ -1006,8 +1006,8 @@
   return true;
 }
 
-// POSIX has an epoch on Jan-1-1970, but Cocoa prefers Jan-1-2001
-// this call gives the POSIX equivalent of the Cocoa epoch
+// POSIX has an epoch on Jan-1-1970, but Cocoa prefers Jan-1-2001 this
+// call gives the POSIX equivalent of the Cocoa epoch
 time_t lldb_private::formatters::GetOSXEpoch() {
   static time_t epoch = 0;
   if (!epoch) {
Index: source/Plugins/Language/ObjC/CoreMedia.cpp
===================================================================
--- source/Plugins/Language/ObjC/CoreMedia.cpp
+++ source/Plugins/Language/ObjC/CoreMedia.cpp
@@ -33,7 +33,8 @@
   if (!type_system)
     return false;
 
-  // fetch children by offset to compensate for potential lack of debug info
+  // fetch children by offset to compensate for potential lack of debug
+  // info
   auto int64_ty =
       type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 64);
   auto int32_ty =
Index: source/Plugins/Language/ObjC/NSError.cpp
===================================================================
--- source/Plugins/Language/ObjC/NSError.cpp
+++ source/Plugins/Language/ObjC/NSError.cpp
@@ -117,8 +117,8 @@
       : SyntheticChildrenFrontEnd(*valobj_sp) {}
 
   ~NSErrorSyntheticFrontEnd() override = default;
-  // no need to delete m_child_ptr - it's kept alive by the cluster manager on
-  // our behalf
+  // no need to delete m_child_ptr - it's kept alive by the cluster
+  // manager on our behalf
 
   size_t CalculateNumChildren() override {
     if (m_child_ptr)
@@ -177,12 +177,11 @@
 
 private:
   // the child here can be "real" (i.e. an actual child of the root) or
-  // synthetized from raw memory
-  // if the former, I need to store a plain pointer to it - or else a loop of
-  // references will cause this entire hierarchy of values to leak
-  // if the latter, then I need to store a SharedPointer to it - so that it only
-  // goes away when everyone else in the cluster goes away
-  // oh joy!
+  // synthetized from raw memory if the former, I need to store a plain
+  // pointer to it - or else a loop of references will cause this entire
+  // hierarchy of values to leak if the latter, then I need to store a
+  // SharedPointer to it - so that it only goes away when everyone else in
+  // the cluster goes away oh joy!
   ValueObject *m_child_ptr;
   ValueObjectSP m_child_sp;
 };
Index: source/Plugins/Language/ObjC/NSException.cpp
===================================================================
--- source/Plugins/Language/ObjC/NSException.cpp
+++ source/Plugins/Language/ObjC/NSException.cpp
@@ -101,8 +101,8 @@
       : SyntheticChildrenFrontEnd(*valobj_sp) {}
 
   ~NSExceptionSyntheticFrontEnd() override = default;
-  // no need to delete m_child_ptr - it's kept alive by the cluster manager on
-  // our behalf
+  // no need to delete m_child_ptr - it's kept alive by the cluster
+  // manager on our behalf
 
   size_t CalculateNumChildren() override {
     if (m_child_ptr)
@@ -171,12 +171,11 @@
 
 private:
   // the child here can be "real" (i.e. an actual child of the root) or
-  // synthetized from raw memory
-  // if the former, I need to store a plain pointer to it - or else a loop of
-  // references will cause this entire hierarchy of values to leak
-  // if the latter, then I need to store a SharedPointer to it - so that it only
-  // goes away when everyone else in the cluster goes away
-  // oh joy!
+  // synthetized from raw memory if the former, I need to store a plain
+  // pointer to it - or else a loop of references will cause this entire
+  // hierarchy of values to leak if the latter, then I need to store a
+  // SharedPointer to it - so that it only goes away when everyone else in
+  // the cluster goes away oh joy!
   ValueObject *m_child_ptr;
   ValueObjectSP m_child_sp;
 };
Index: source/Plugins/Language/ObjC/NSString.cpp
===================================================================
--- source/Plugins/Language/ObjC/NSString.cpp
+++ source/Plugins/Language/ObjC/NSString.cpp
@@ -255,9 +255,9 @@
   } else if (is_inline) {
     uint64_t location = valobj_addr + 2 * ptr_size;
     if (!has_explicit_length) {
-      // in this kind of string, the byte before the string content is a length
-      // byte
-      // so let's try and use it to handle the embedded NUL case
+      // in this kind of string, the byte before the string content is a
+      // length byte so let's try and use it to handle the embedded NUL
+      // case
       Status error;
       explicit_length =
           process_sp->ReadUnsignedIntegerFromMemory(location, 1, 0, error);
@@ -367,11 +367,9 @@
     }
   }
 
-  // this is a fairly ugly trick - pretend that the numeric value is actually a
-  // char*
-  // this works under a few assumptions:
-  // little endian architecture
-  // sizeof(uint64_t) > g_MaxNonBitmaskedLen
+  // this is a fairly ugly trick - pretend that the numeric value is
+  // actually a char* this works under a few assumptions: little endian
+  // architecture sizeof(uint64_t) > g_MaxNonBitmaskedLen
   if (len_bits <= g_MaxNonBitmaskedLen) {
     stream.Printf("%s", prefix.c_str());
     stream.Printf("\"%s\"", (const char *)&data_bits);
Index: source/Plugins/Language/ObjC/ObjCLanguage.cpp
===================================================================
--- source/Plugins/Language/ObjC/ObjCLanguage.cpp
+++ source/Plugins/Language/ObjC/ObjCLanguage.cpp
@@ -90,9 +90,9 @@
   if (name.empty())
     return IsValid(strict);
 
-  // If "strict" is true. then the method must be specified with a
-  // '+' or '-' at the beginning. If "strict" is false, then the '+'
-  // or '-' can be omitted
+  // If "strict" is true. then the method must be specified with a '+' or
+  // '-' at the beginning. If "strict" is false, then the '+' or '-' can
+  // be omitted
   bool valid_prefix = false;
 
   if (name.size() > 1 && (name[0] == '+' || name[0] == '-')) {
@@ -134,14 +134,15 @@
       if (paren_pos) {
         m_class.SetCStringWithLength(class_start, paren_pos - class_start);
       } else {
-        // No '(' was found in the full name, we can definitively say
-        // that our category was valid (and empty).
+        // No '(' was found in the full name, we can definitively say that
+        // our category was valid (and empty).
         m_category_is_valid = true;
         const char *space_pos = strchr(full, ' ');
         if (space_pos) {
           m_class.SetCStringWithLength(class_start, space_pos - class_start);
           if (!m_class_category) {
-            // No category in name, so we can also fill in the m_class_category
+            // No category in name, so we can also fill in the
+            // m_class_category
             m_class_category = m_class;
           }
         }
@@ -160,8 +161,8 @@
       if (space_pos) {
         m_class_category.SetCStringWithLength(class_start,
                                               space_pos - class_start);
-        // If m_class hasn't been filled in and the class with category doesn't
-        // contain a '(', then we can also fill in the m_class
+        // If m_class hasn't been filled in and the class with category
+        // doesn't contain a '(', then we can also fill in the m_class
         if (!m_class && strchr(m_class_category.GetCString(), '(') == nullptr) {
           m_class = m_class_category;
           // No '(' was found in the full name, we can definitively say
@@ -796,9 +797,9 @@
       objc_category_sp, lldb_private::formatters::NSTimeZoneSummaryProvider,
       "NSTimeZone summary provider", ConstString("__NSTimeZone"), appkit_flags);
 
-  // CFAbsoluteTime is actually a double rather than a pointer to an object
-  // we do not care about the numeric value, since it is probably meaningless to
-  // users
+  // CFAbsoluteTime is actually a double rather than a pointer to an
+  // object we do not care about the numeric value, since it is probably
+  // meaningless to users
   appkit_flags.SetDontShowValue(true);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::CFAbsoluteTimeSummaryProvider,
Index: source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp
===================================================================
--- source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp
+++ source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp
@@ -80,11 +80,11 @@
                           ": static-type = '%s' has vtable symbol '%s'\n",
                           original_ptr, in_value.GetTypeName().GetCString(),
                           name);
-            // We are a C++ class, that's good.  Get the class name and look it
-            // up:
+            // We are a C++ class, that's good.  Get the class name and
+            // look it up:
             const char *class_name = name + strlen(vtable_demangled_prefix);
-            // We know the class name is absolute, so tell FindTypes that by
-            // prefixing it with the root namespace:
+            // We know the class name is absolute, so tell FindTypes that
+            // by prefixing it with the root namespace:
             std::string lookup_name("::");
             lookup_name.append(class_name);
             
@@ -103,8 +103,8 @@
             }
 
             // If we didn't find a symbol, then move on to the entire
-            // module list in the target and get as many unique matches
-            // as possible
+            // module list in the target and get as many unique matches as
+            // possible
             if (num_matches == 0) {
               num_matches = target.GetImages().FindTypes(
                   sc, ConstString(lookup_name), exact_match, UINT32_MAX,
@@ -191,23 +191,20 @@
     ValueObject &in_value, lldb::DynamicValueType use_dynamic,
     TypeAndOrName &class_type_or_name, Address &dynamic_address,
     Value::ValueType &value_type) {
-  // For Itanium, if the type has a vtable pointer in the object, it will be at
-  // offset 0
-  // in the object.  That will point to the "address point" within the vtable
-  // (not the beginning of the
-  // vtable.)  We can then look up the symbol containing this "address point"
-  // and that symbol's name
-  // demangled will contain the full class name.
-  // The second pointer above the "address point" is the "offset_to_top".  We'll
-  // use that to get the
-  // start of the value object which holds the dynamic type.
+  // For Itanium, if the type has a vtable pointer in the object, it will
+  // be at offset 0 in the object.  That will point to the "address point"
+  // within the vtable (not the beginning of the vtable.)  We can then
+  // look up the symbol containing this "address point" and that symbol's
+  // name demangled will contain the full class name. The second pointer
+  // above the "address point" is the "offset_to_top".  We'll use that to
+  // get the start of the value object which holds the dynamic type.
   //
 
   class_type_or_name.Clear();
   value_type = Value::ValueType::eValueTypeScalar;
 
-  // Only a pointer or reference type can have a different dynamic and static
-  // type:
+  // Only a pointer or reference type can have a different dynamic and
+  // static type:
   if (CouldHaveDynamicValue(in_value)) {
     // First job, pull out the address at 0 offset from the object.
     AddressType address_type;
@@ -235,17 +232,16 @@
 
     if (class_type_or_name) {
       TypeSP type_sp = class_type_or_name.GetTypeSP();
-      // There can only be one type with a given name,
-      // so we've just found duplicate definitions, and this
-      // one will do as well as any other.
-      // We don't consider something to have a dynamic type if
-      // it is the same as the static type.  So compare against
-      // the value we were handed.
+      // There can only be one type with a given name, so we've just found
+      // duplicate definitions, and this one will do as well as any other.
+      // We don't consider something to have a dynamic type if it is the
+      // same as the static type.  So compare against the value we were
+      // handed.
       if (type_sp) {
         if (ClangASTContext::AreTypesSame(in_value.GetCompilerType(),
                                           type_sp->GetForwardCompilerType())) {
-          // The dynamic type we found was the same type,
-          // so we don't have a dynamic type here...
+          // The dynamic type we found was the same type, so we don't have
+          // a dynamic type here...
           return false;
         }
 
@@ -284,11 +280,10 @@
 
   TypeAndOrName ret(type_and_or_name);
   if (type_and_or_name.HasType()) {
-    // The type will always be the type of the dynamic object.  If our parent's
-    // type was a pointer,
-    // then our type should be a pointer to the type of the dynamic object.  If
-    // a reference, then the original type
-    // should be okay...
+    // The type will always be the type of the dynamic object.  If our
+    // parent's type was a pointer, then our type should be a pointer to
+    // the type of the dynamic object.  If a reference, then the original
+    // type should be okay...
     CompilerType orig_type = type_and_or_name.GetCompilerType();
     CompilerType corrected_type = orig_type;
     if (static_type_flags.AllSet(eTypeIsPointer))
@@ -297,14 +292,15 @@
       corrected_type = orig_type.GetLValueReferenceType();
     ret.SetCompilerType(corrected_type);
   } else {
-    // If we are here we need to adjust our dynamic type name to include the
-    // correct & or * symbol
+    // If we are here we need to adjust our dynamic type name to include
+    // the correct & or * symbol
     std::string corrected_name(type_and_or_name.GetName().GetCString());
     if (static_type_flags.AllSet(eTypeIsPointer))
       corrected_name.append(" *");
     else if (static_type_flags.AllSet(eTypeIsReference))
       corrected_name.append(" &");
-    // the parent type should be a correctly pointer'ed or referenc'ed type
+    // the parent type should be a correctly pointer'ed or referenc'ed
+    // type
     ret.SetCompilerType(static_type);
     ret.SetName(corrected_name.c_str());
   }
@@ -328,9 +324,8 @@
 LanguageRuntime *
 ItaniumABILanguageRuntime::CreateInstance(Process *process,
                                           lldb::LanguageType language) {
-  // FIXME: We have to check the process and make sure we actually know that
-  // this process supports
-  // the Itanium ABI.
+  // FIXME: We have to check the process and make sure we actually know
+  // that this process supports the Itanium ABI.
   if (language == eLanguageTypeC_plus_plus ||
       language == eLanguageTypeC_plus_plus_03 ||
       language == eLanguageTypeC_plus_plus_11 ||
@@ -372,10 +367,10 @@
         continue;
 
       // the actual Mangled class should be strict about this, but on the
-      // command line if you're copying mangled names out of 'nm' on Darwin,
-      // they will come out with an extra underscore - be willing to strip
-      // this on behalf of the user.   This is the moral equivalent of the -_/-n
-      // options to c++filt
+      // command line if you're copying mangled names out of 'nm' on
+      // Darwin, they will come out with an extra underscore - be willing
+      // to strip this on behalf of the user.   This is the moral
+      // equivalent of the -_/-n options to c++filt
       auto name = entry.ref;
       if (name.startswith("__Z"))
         name = name.drop_front();
@@ -453,13 +448,12 @@
 BreakpointResolverSP ItaniumABILanguageRuntime::CreateExceptionResolver(
     Breakpoint *bkpt, bool catch_bp, bool throw_bp, bool for_expressions) {
   // One complication here is that most users DON'T want to stop at
-  // __cxa_allocate_expression, but until we can do
-  // anything better with predicting unwinding the expression parser does.  So
-  // we have two forms of the exception
-  // breakpoints, one for expressions that leaves out __cxa_allocate_exception,
-  // and one that includes it.
-  // The SetExceptionBreakpoints does the latter, the CreateExceptionBreakpoint
-  // in the runtime the former.
+  // __cxa_allocate_expression, but until we can do anything better with
+  // predicting unwinding the expression parser does.  So we have two
+  // forms of the exception breakpoints, one for expressions that leaves
+  // out __cxa_allocate_exception, and one that includes it. The
+  // SetExceptionBreakpoints does the latter, the
+  // CreateExceptionBreakpoint in the runtime the former.
   static const char *g_catch_name = "__cxa_begin_catch";
   static const char *g_throw_name1 = "__cxa_throw";
   static const char *g_throw_name2 = "__cxa_rethrow";
@@ -488,8 +482,8 @@
   Target &target = m_process->GetTarget();
 
   if (target.GetArchitecture().GetTriple().getVendor() == llvm::Triple::Apple) {
-    // Limit the number of modules that are searched for these breakpoints for
-    // Apple binaries.
+    // Limit the number of modules that are searched for these breakpoints
+    // for Apple binaries.
     FileSpecList filter_modules;
     filter_modules.Append(FileSpec("libc++abi.dylib", false));
     filter_modules.Append(FileSpec("libSystem.B.dylib", false));
@@ -521,9 +515,8 @@
   const bool is_internal = true;
   const bool for_expressions = true;
 
-  // For the exception breakpoints set by the Expression parser, we'll be a
-  // little more aggressive and
-  // stop at exception allocation as well.
+  // For the exception breakpoints set by the Expression parser, we'll be
+  // a little more aggressive and stop at exception allocation as well.
 
   if (m_cxx_exception_bp_sp) {
     m_cxx_exception_bp_sp->SetEnabled(true);
Index: source/Plugins/LanguageRuntime/Go/GoLanguageRuntime.cpp
===================================================================
--- source/Plugins/LanguageRuntime/Go/GoLanguageRuntime.cpp
+++ source/Plugins/LanguageRuntime/Go/GoLanguageRuntime.cpp
@@ -159,9 +159,9 @@
     if (direct) {
       class_type_or_name.SetCompilerType(final_type);
     } else {
-      // TODO: implement reference types or fix caller to support dynamic types
-      // that aren't pointers
-      // so we don't have to introduce this extra pointer.
+      // TODO: implement reference types or fix caller to support dynamic
+      // types that aren't pointers so we don't have to introduce this
+      // extra pointer.
       class_type_or_name.SetCompilerType(final_type.GetPointerType());
     }
 
Index: source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp
===================================================================
--- source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp
+++ source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp
@@ -377,9 +377,8 @@
   if (class_method_func) {
     AppleObjCRuntime::ClassDescriptorSP metaclass(GetMetaclass());
 
-    // We don't care about the metaclass's superclass, or its class methods.
-    // Its instance methods are
-    // our class methods.
+    // We don't care about the metaclass's superclass, or its class
+    // methods. Its instance methods are our class methods.
 
     if (metaclass) {
       metaclass->Describe(
Index: source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp
===================================================================
--- source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp
+++ source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp
@@ -53,24 +53,21 @@
 bool AppleObjCRuntime::GetObjectDescription(Stream &str, ValueObject &valobj) {
   CompilerType compiler_type(valobj.GetCompilerType());
   bool is_signed;
-  // ObjC objects can only be pointers (or numbers that actually represents
-  // pointers
-  // but haven't been typecast, because reasons..)
+  // ObjC objects can only be pointers (or numbers that actually
+  // represents pointers but haven't been typecast, because reasons..)
   if (!compiler_type.IsIntegerType(is_signed) && !compiler_type.IsPointerType())
     return false;
 
-  // Make the argument list: we pass one arg, the address of our pointer, to the
-  // print function.
+  // Make the argument list: we pass one arg, the address of our pointer,
+  // to the print function.
   Value val;
 
   if (!valobj.ResolveValue(val.GetScalar()))
     return false;
 
-  // Value Objects may not have a process in their ExecutionContextRef.  But we
-  // need to have one
-  // in the ref we pass down to eventually call description.  Get it from the
-  // target if it isn't
-  // present.
+  // Value Objects may not have a process in their ExecutionContextRef.
+  // But we need to have one in the ref we pass down to eventually call
+  // description.  Get it from the target if it isn't present.
   ExecutionContext exe_ctx;
   if (valobj.GetProcessSP()) {
     exe_ctx = ExecutionContext(valobj.GetExecutionContextRef());
@@ -256,23 +253,23 @@
 
   TypeAndOrName ret(type_and_or_name);
   if (type_and_or_name.HasType()) {
-    // The type will always be the type of the dynamic object.  If our parent's
-    // type was a pointer,
-    // then our type should be a pointer to the type of the dynamic object.  If
-    // a reference, then the original type
-    // should be okay...
+    // The type will always be the type of the dynamic object.  If our
+    // parent's type was a pointer, then our type should be a pointer to
+    // the type of the dynamic object.  If a reference, then the original
+    // type should be okay...
     CompilerType orig_type = type_and_or_name.GetCompilerType();
     CompilerType corrected_type = orig_type;
     if (static_type_flags.AllSet(eTypeIsPointer))
       corrected_type = orig_type.GetPointerType();
     ret.SetCompilerType(corrected_type);
   } else {
-    // If we are here we need to adjust our dynamic type name to include the
-    // correct & or * symbol
+    // If we are here we need to adjust our dynamic type name to include
+    // the correct & or * symbol
     std::string corrected_name(type_and_or_name.GetName().GetCString());
     if (static_type_flags.AllSet(eTypeIsPointer))
       corrected_name.append(" *");
-    // the parent type should be a correctly pointer'ed or referenc'ed type
+    // the parent type should be a correctly pointer'ed or referenc'ed
+    // type
     ret.SetCompilerType(static_type);
     ret.SetName(corrected_name.c_str());
   }
@@ -292,8 +289,8 @@
   return false;
 }
 
-// we use the version of Foundation to make assumptions about the ObjC runtime
-// on a target
+// we use the version of Foundation to make assumptions about the ObjC
+// runtime on a target
 uint32_t AppleObjCRuntime::GetFoundationVersion() {
   if (!m_Foundation_major.hasValue()) {
     const ModuleList &modules = m_process->GetTarget().GetImages();
@@ -324,9 +321,9 @@
 }
 
 bool AppleObjCRuntime::ReadObjCLibrary(const ModuleSP &module_sp) {
-  // Maybe check here and if we have a handler already, and the UUID of this
-  // module is the same as the one in the
-  // current module, then we don't have to reread it?
+  // Maybe check here and if we have a handler already, and the UUID of
+  // this module is the same as the one in the current module, then we
+  // don't have to reread it?
   m_objc_trampoline_handler_ap.reset(
       new AppleObjCTrampolineHandler(m_process->shared_from_this(), module_sp));
   if (m_objc_trampoline_handler_ap.get() != NULL) {
@@ -364,13 +361,11 @@
   size_t num_images = target_modules.GetSize();
   for (size_t i = 0; i < num_images; i++) {
     ModuleSP module_sp = target_modules.GetModuleAtIndexUnlocked(i);
-    // One tricky bit here is that we might get called as part of the initial
-    // module loading, but
-    // before all the pre-run libraries get winnowed from the module list.  So
-    // there might actually
-    // be an old and incorrect ObjC library sitting around in the list, and we
-    // don't want to look at that.
-    // That's why we call IsLoadedInTarget.
+    // One tricky bit here is that we might get called as part of the
+    // initial module loading, but before all the pre-run libraries get
+    // winnowed from the module list.  So there might actually be an old
+    // and incorrect ObjC library sitting around in the list, and we don't
+    // want to look at that. That's why we call IsLoadedInTarget.
 
     if (AppleIsModuleObjCLibrary(module_sp) &&
         module_sp->IsLoadedInTarget(&target)) {
Index: source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp
===================================================================
--- source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp
+++ source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp
@@ -41,9 +41,8 @@
     : AppleObjCRuntime(process), m_hash_signature(),
       m_isa_hash_table_ptr(LLDB_INVALID_ADDRESS) {}
 
-// for V1 runtime we just try to return a class name as that is the minimum
-// level of support
-// required for the data formatters to work
+// for V1 runtime we just try to return a class name as that is the
+// minimum level of support required for the data formatters to work
 bool AppleObjCRuntimeV1::GetDynamicTypeAndAddress(
     ValueObject &in_value, lldb::DynamicValueType use_dynamic,
     TypeAndOrName &class_type_or_name, Address &address,
@@ -68,9 +67,8 @@
 lldb_private::LanguageRuntime *
 AppleObjCRuntimeV1::CreateInstance(Process *process,
                                    lldb::LanguageType language) {
-  // FIXME: This should be a MacOS or iOS process, and we need to look for the
-  // OBJC section to make
-  // sure we aren't using the V1 runtime.
+  // FIXME: This should be a MacOS or iOS process, and we need to look for
+  // the OBJC section to make sure we aren't using the V1 runtime.
   if (language == eLanguageTypeObjC) {
     ModuleSP objc_module_sp;
 
@@ -322,8 +320,8 @@
   Process *process = GetProcess();
 
   if (process) {
-    // Update the process stop ID that indicates the last time we updated the
-    // map, whether it was successful or not.
+    // Update the process stop ID that indicates the last time we updated
+    // the map, whether it was successful or not.
     m_isa_to_descriptor_stop_id = process->GetStopID();
 
     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
@@ -383,8 +381,8 @@
 
               ObjCISA isa;
               if (bucket_isa_count == 1) {
-                // When we only have one entry in the bucket, the bucket data is
-                // the "isa"
+                // When we only have one entry in the bucket, the bucket
+                // data is the "isa"
                 isa = bucket_data;
                 if (isa) {
                   if (!ISAIsCached(isa)) {
@@ -401,9 +399,8 @@
                   }
                 }
               } else {
-                // When we have more than one entry in the bucket, the bucket
-                // data is a pointer
-                // to an array of "isa" values
+                // When we have more than one entry in the bucket, the
+                // bucket data is a pointer to an array of "isa" values
                 addr_t isa_addr = bucket_data;
                 for (uint32_t isa_idx = 0; isa_idx < bucket_isa_count;
                      ++isa_idx, isa_addr += addr_size) {
Index: source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp
===================================================================
--- source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp
+++ source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp
@@ -76,9 +76,8 @@
 
 static const char *g_get_dynamic_class_info_name =
     "__lldb_apple_objc_v2_get_dynamic_class_info";
-// Testing using the new C++11 raw string literals. If this breaks GCC then we
-// will
-// need to revert to the code above...
+// Testing using the new C++11 raw string literals. If this breaks GCC
+// then we will need to revert to the code above...
 static const char *g_get_dynamic_class_info_body = R"(
 
 extern "C"
@@ -161,9 +160,8 @@
 
 static const char *g_get_shared_cache_class_info_name =
     "__lldb_apple_objc_v2_get_shared_cache_class_info";
-// Testing using the new C++11 raw string literals. If this breaks GCC then we
-// will
-// need to revert to the code above...
+// Testing using the new C++11 raw string literals. If this breaks GCC
+// then we will need to revert to the code above...
 static const char *g_get_shared_cache_class_info_body = R"(
 
 extern "C"
@@ -261,7 +259,8 @@
             DEBUG_PRINTF("max_class_infos = %llu\n", (uint64_t)max_class_infos);
             ClassInfo *class_infos = (ClassInfo *)class_infos_ptr;
             int32_t invalidEntryOffset = 0;
-            // this is safe to do because the version field order is invariant
+            // this is safe to do because the version field order is
+            // invariant
             if (objc_opt->version == 12)
                 invalidEntryOffset = 16;
             const uint8_t *checkbytes = &clsopt->tab[clsopt->mask+1];
@@ -406,11 +405,11 @@
   // We should never get here with a null process...
   assert(m_process != NULL);
 
-  // The Runtime is attached to a particular process, you shouldn't pass in a
-  // value from another process.
-  // Note, however, the process might be NULL (e.g. if the value was made with
-  // SBTarget::EvaluateExpression...)
-  // in which case it is sufficient if the target's match:
+  // The Runtime is attached to a particular process, you shouldn't pass
+  // in a value from another process. Note, however, the process might be
+  // NULL (e.g. if the value was made with
+  // SBTarget::EvaluateExpression...) in which case it is sufficient if
+  // the target's match:
 
   Process *process = in_value.GetProcessSP().get();
   if (process)
@@ -423,8 +422,8 @@
 
   // Make sure we can have a dynamic value before starting...
   if (CouldHaveDynamicValue(in_value)) {
-    // First job, pull out the address at 0 offset from the object  That will be
-    // the ISA pointer.
+    // First job, pull out the address at 0 offset from the object  That
+    // will be the ISA pointer.
     ClassDescriptorSP objc_class_sp(GetNonKVOClassDescriptor(in_value));
     if (objc_class_sp) {
       const addr_t object_ptr = in_value.GetPointerValue();
@@ -461,9 +460,8 @@
 //------------------------------------------------------------------
 LanguageRuntime *AppleObjCRuntimeV2::CreateInstance(Process *process,
                                                     LanguageType language) {
-  // FIXME: This should be a MacOS or iOS process, and we need to look for the
-  // OBJC section to make
-  // sure we aren't using the V1 runtime.
+  // FIXME: This should be a MacOS or iOS process, and we need to look for
+  // the OBJC section to make sure we aren't using the V1 runtime.
   if (language == eLanguageTypeObjC) {
     ModuleSP objc_module_sp;
 
@@ -806,9 +804,8 @@
     resolver_sp.reset(new BreakpointResolverName(
         bkpt, "objc_exception_throw", eFunctionNameTypeBase,
         eLanguageTypeUnknown, Breakpoint::Exact, 0, eLazyBoolNo));
-  // FIXME: We don't do catch breakpoints for ObjC yet.
-  // Should there be some way for the runtime to specify what it can do in this
-  // regard?
+  // FIXME: We don't do catch breakpoints for ObjC yet. Should there be
+  // some way for the runtime to specify what it can do in this regard?
   return resolver_sp;
 }
 
@@ -881,8 +878,8 @@
     ConstString ivar_const_str(buffer.c_str());
 
     //----------------------------------------------------------------------
-    // Try to get the ivar offset address from the symbol table first using
-    // the name we created above
+    // Try to get the ivar offset address from the symbol table first
+    // using the name we created above
     //----------------------------------------------------------------------
     SymbolContextList sc_list;
     Target &target = m_process->GetTarget();
@@ -901,8 +898,8 @@
     }
 
     //----------------------------------------------------------------------
-    // If we didn't get the ivar offset address from the symbol table, fall
-    // back to getting it from the runtime
+    // If we didn't get the ivar offset address from the symbol table,
+    // fall back to getting it from the runtime
     //----------------------------------------------------------------------
     if (ivar_offset_address == LLDB_INVALID_ADDRESS)
       ivar_offset_address = LookupRuntimeSymbol(ivar_const_str);
@@ -914,11 +911,10 @@
   return ivar_offset;
 }
 
-// tagged pointers are special not-a-real-pointer values that contain both type
-// and value information
-// this routine attempts to check with as little computational effort as
-// possible whether something
-// could possibly be a tagged pointer - false positives are possible but false
+// tagged pointers are special not-a-real-pointer values that contain both
+// type and value information this routine attempts to check with as
+// little computational effort as possible whether something could
+// possibly be a tagged pointer - false positives are possible but false
 // negatives shouldn't
 bool AppleObjCRuntimeV2::IsTaggedPointer(addr_t ptr) {
   if (!m_tagged_pointer_vendor_ap)
@@ -950,12 +946,12 @@
         m_process->GetAddressByteSize() == 8 ? UINT64_MAX : UINT32_MAX;
     Status err;
 
-    // This currently holds true for all platforms we support, but we might
-    // need to change this to use get the actually byte size of "unsigned"
-    // from the target AST...
+    // This currently holds true for all platforms we support, but we
+    // might need to change this to use get the actually byte size of
+    // "unsigned" from the target AST...
     const uint32_t unsigned_byte_size = sizeof(uint32_t);
-    // Skip the prototype as we don't need it (const struct +NXMapTablePrototype
-    // *prototype)
+    // Skip the prototype as we don't need it (const struct
+    // +NXMapTablePrototype *prototype)
 
     bool success = true;
     if (load_addr == LLDB_INVALID_ADDRESS)
@@ -989,8 +985,8 @@
     return success;
   }
 
-  // const_iterator mimics NXMapState and its code comes from NXInitMapState and
-  // NXNextMapState.
+  // const_iterator mimics NXMapState and its code comes from
+  // NXInitMapState and NXNextMapState.
   typedef std::pair<ConstString, ObjCLanguageRuntime::ObjCISA> element;
 
   friend class const_iterator;
@@ -1133,8 +1129,8 @@
     return false; // Failed to parse the header, no need to update anything
   }
 
-  // Check with out current signature and return true if the count,
-  // number of buckets or the hash table address changes.
+  // Check with out current signature and return true if the count, number
+  // of buckets or the hash table address changes.
   if (m_count == hash_table.GetCount() &&
       m_num_buckets == hash_table.GetBucketCount() &&
       m_buckets_ptr == hash_table.GetBucketDataPointer()) {
@@ -1303,7 +1299,8 @@
     if (!m_get_class_info_code.get())
       return DescriptorMapUpdateResult::Fail();
 
-    // Next make the runner function for our implementation utility function.
+    // Next make the runner function for our implementation utility
+    // function.
     Value value;
     value.SetValueType(Value::eValueTypeScalar);
     value.SetCompilerType(clang_void_pointer_type);
@@ -1371,7 +1368,8 @@
 
   diagnostics.Clear();
 
-  // Write our function arguments into the process so we can run our function
+  // Write our function arguments into the process so we can run our
+  // function
   if (get_class_info_function->WriteFunctionArguments(
           exe_ctx, m_get_class_info_args, arguments, diagnostics)) {
     EvaluateExpressionOptions options;
@@ -1395,7 +1393,8 @@
         exe_ctx, &m_get_class_info_args, options, diagnostics, return_value);
 
     if (results == eExpressionCompleted) {
-      // The result is the number of ClassInfo structures that were filled in
+      // The result is the number of ClassInfo structures that were filled
+      // in
       num_class_infos = return_value.GetScalar().ULong();
       if (log)
         log->Printf("Discovered %u ObjC classes\n", num_class_infos);
@@ -1557,16 +1556,19 @@
     if (!m_get_shared_cache_class_info_code.get())
       return DescriptorMapUpdateResult::Fail();
 
-    // Next make the function caller for our implementation utility function.
+    // Next make the function caller for our implementation utility
+    // function.
     Value value;
     value.SetValueType(Value::eValueTypeScalar);
-    // value.SetContext (Value::eContextTypeClangType, clang_void_pointer_type);
+    // value.SetContext (Value::eContextTypeClangType,
+    // clang_void_pointer_type);
     value.SetCompilerType(clang_void_pointer_type);
     arguments.PushValue(value);
     arguments.PushValue(value);
 
     value.SetValueType(Value::eValueTypeScalar);
-    // value.SetContext (Value::eContextTypeClangType, clang_uint32_t_type);
+    // value.SetContext (Value::eContextTypeClangType,
+    // clang_uint32_t_type);
     value.SetCompilerType(clang_uint32_t_type);
     arguments.PushValue(value);
     arguments.PushValue(value);
@@ -1618,7 +1620,8 @@
 
   diagnostics.Clear();
 
-  // Write our function arguments into the process so we can run our function
+  // Write our function arguments into the process so we can run our
+  // function
   if (get_shared_cache_class_info_function->WriteFunctionArguments(
           exe_ctx, m_get_shared_cache_class_info_args, arguments,
           diagnostics)) {
@@ -1645,7 +1648,8 @@
             return_value);
 
     if (results == eExpressionCompleted) {
-      // The result is the number of ClassInfo structures that were filled in
+      // The result is the number of ClassInfo structures that were filled
+      // in
       num_class_infos = return_value.GetScalar().ULong();
       if (log)
         log->Printf("Discovered %u ObjC classes in shared cache\n",
@@ -1769,14 +1773,15 @@
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
-  // Else we need to check with our process to see when the map was updated.
+  // Else we need to check with our process to see when the map was
+  // updated.
   Process *process = GetProcess();
 
   if (process) {
     RemoteNXMapTable hash_table;
 
-    // Update the process stop ID that indicates the last time we updated the
-    // map, whether it was successful or not.
+    // Update the process stop ID that indicates the last time we updated
+    // the map, whether it was successful or not.
     m_isa_to_descriptor_stop_id = process->GetStopID();
 
     if (!m_hash_signature.NeedsUpdate(process, this, hash_table))
@@ -1784,24 +1789,23 @@
 
     m_hash_signature.UpdateSignature(hash_table);
 
-    // Grab the dynamically loaded objc classes from the hash table in memory
+    // Grab the dynamically loaded objc classes from the hash table in
+    // memory
     DescriptorMapUpdateResult dynamic_update_result =
         UpdateISAToDescriptorMapDynamic(hash_table);
 
-    // Now get the objc classes that are baked into the Objective C runtime
-    // in the shared cache, but only once per process as this data never
-    // changes
+    // Now get the objc classes that are baked into the Objective C
+    // runtime in the shared cache, but only once per process as this data
+    // never changes
     if (!m_loaded_objc_opt) {
-      // it is legitimately possible for the shared cache to be empty - in that
-      // case, the dynamic hash table
-      // will contain all the class information we need; the situation we're
-      // trying to detect is one where
-      // we aren't seeing class information from the runtime - in order to
-      // detect that vs. just the shared cache
-      // being empty or sparsely populated, we set an arbitrary (very low)
-      // threshold for the number of classes
-      // that we want to see in a "good" scenario - anything below that is
-      // suspicious (Foundation alone has thousands
+      // it is legitimately possible for the shared cache to be empty - in
+      // that case, the dynamic hash table will contain all the class
+      // information we need; the situation we're trying to detect is one
+      // where we aren't seeing class information from the runtime - in
+      // order to detect that vs. just the shared cache being empty or
+      // sparsely populated, we set an arbitrary (very low) threshold for
+      // the number of classes that we want to see in a "good" scenario -
+      // anything below that is suspicious (Foundation alone has thousands
       // of classes)
       const uint32_t num_classes_to_warn_at = 500;
 
@@ -1858,8 +1862,8 @@
     return;
 
   if (GetProcess() && !DoesProcessHaveSharedCache(*GetProcess())) {
-    // Simulators do not have the objc_opt_ro class table so don't actually
-    // complain to the user
+    // Simulators do not have the objc_opt_ro class table so don't
+    // actually complain to the user
     m_noclasses_warning_emitted = true;
     return;
   }
@@ -2035,8 +2039,8 @@
   if (log)
     log->PutCString("AOCRT::NPI: Found all the indexed ISA masks");
 
-  // we might want to have some rules to outlaw these other values (e.g if the
-  // mask is zero but the value is non-zero, ...)
+  // we might want to have some rules to outlaw these other values (e.g if
+  // the mask is zero but the value is non-zero, ...)
 
   return new NonPointerISACache(
       runtime, objc_module_sp, objc_debug_isa_class_mask,
@@ -2089,8 +2093,8 @@
   if (error.Fail())
     return new TaggedPointerVendorLegacy(runtime);
 
-  // try to detect the "extended tagged pointer" variables - if any are missing,
-  // use the non-extended vendor
+  // try to detect the "extended tagged pointer" variables - if any are
+  // missing, use the non-extended vendor
   do {
     auto objc_debug_taggedpointer_ext_mask = ExtractRuntimeGlobalSymbol(
         process, ConstString("objc_debug_taggedpointer_ext_mask"),
@@ -2143,8 +2147,8 @@
         objc_debug_taggedpointer_classes, objc_debug_taggedpointer_ext_classes);
   } while (false);
 
-  // we might want to have some rules to outlaw these values (e.g if the table's
-  // address is zero)
+  // we might want to have some rules to outlaw these values (e.g if the
+  // table's address is zero)
 
   return new TaggedPointerVendorRuntimeAssisted(
       runtime, objc_debug_taggedpointer_mask,
@@ -2416,9 +2420,8 @@
 
   // If all of the indexed ISA variables are set, then its possible that
   // this ISA is indexed, and we should first try to get its value using
-  // the index.
-  // Note, we check these varaibles first as the ObjC runtime will set at
-  // least one of their values to 0 if they aren't needed.
+  // the index. Note, we check these varaibles first as the ObjC runtime
+  // will set at least one of their values to 0 if they aren't needed.
   if (m_objc_debug_indexed_isa_magic_mask &&
       m_objc_debug_indexed_isa_magic_value &&
       m_objc_debug_indexed_isa_index_mask &&
@@ -2432,8 +2435,8 @@
       uintptr_t index = (isa & m_objc_debug_indexed_isa_index_mask) >>
                         m_objc_debug_indexed_isa_index_shift;
       // If the index is out of bounds of the length of the array then
-      // check if the array has been updated.  If that is the case then
-      // we should try read the count again, and update the cache if the
+      // check if the array has been updated.  If that is the case then we
+      // should try read the count again, and update the cache if the
       // count has been updated.
       if (index > m_indexed_isa_cache.size()) {
         if (log)
@@ -2459,9 +2462,9 @@
                       (uint64_t)objc_indexed_classes_count);
 
         if (objc_indexed_classes_count > m_indexed_isa_cache.size()) {
-          // Read the class entries we don't have.  We should just
-          // read all of them instead of just the one we need as then
-          // we can cache those we may need later.
+          // Read the class entries we don't have.  We should just read
+          // all of them instead of just the one we need as then we can
+          // cache those we may need later.
           auto num_new_classes =
               objc_indexed_classes_count - m_indexed_isa_cache.size();
           const uint32_t addr_size = process->GetAddressByteSize();
@@ -2504,8 +2507,8 @@
     return false;
   }
 
-  // Definately not an indexed ISA, so try to use a mask to extract
-  // the pointer from the ISA.
+  // Definately not an indexed ISA, so try to use a mask to extract the
+  // pointer from the ISA.
   if ((isa & m_objc_debug_isa_magic_mask) == m_objc_debug_isa_magic_value) {
     ret_isa = isa & m_objc_debug_isa_class_mask;
     return (ret_isa != 0); // this is a pointer so 0 is not a valid value
Index: source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp
===================================================================
--- source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp
+++ source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp
@@ -105,11 +105,14 @@
     }                                                                                                           \n\
     else                                                                                                        \n\
     {                                                                                                           \n\
-        // This code seems a little funny, but has its reasons...                                               \n\
-        // The call to [object class] is here because if this is a class, and has not been called into          \n\
-        // yet, we need to do something to force the class to initialize itself.                                \n\
-        // Then the call to object_getClass will actually return the correct class, either the class            \n\
-        // if object is a class instance, or the meta-class if it is a class pointer.                           \n\
+        // This code seems a little funny, but has its reasons...
+        // \n\ The call to [object class] is here because if this is a
+        // class, and has not been called into          \n\ yet, we need
+        // to do something to force the class to initialize itself.
+        // \n\ Then the call to object_getClass will actually return the
+        // correct class, either the class            \n\ if object is a
+        // class instance, or the meta-class if it is a class pointer.
+        // \n\
         void *class_ptr = (void *) [(id) object class];                                                         \n\
         return_struct.class_addr = (id)  object_getClass((id) object);                                          \n\
         if (debug)                                                                                              \n\
@@ -221,11 +224,14 @@
     }                                                                                                           \n\
     else                                                                                                        \n\
     {                                                                                                           \n\
-        // This code seems a little funny, but has its reasons...                                               \n\
-        // The call to [object class] is here because if this is a class, and has not been called into          \n\
-        // yet, we need to do something to force the class to initialize itself.                                \n\
-        // Then the call to object_getClass will actually return the correct class, either the class            \n\
-        // if object is a class instance, or the meta-class if it is a class pointer.                           \n\
+        // This code seems a little funny, but has its reasons...
+        // \n\ The call to [object class] is here because if this is a
+        // class, and has not been called into          \n\ yet, we need
+        // to do something to force the class to initialize itself.
+        // \n\ Then the call to object_getClass will actually return the
+        // correct class, either the class            \n\ if object is a
+        // class instance, or the meta-class if it is a class pointer.
+        // \n\
         void *class_ptr = (void *) [(id) object class];                                                         \n\
         return_struct.class_addr = (id)  object_getClass((id) object);                                          \n\
         if (debug)                                                                                              \n\
@@ -314,9 +320,8 @@
 
   m_next_region = data.GetPointer(&offset);
 
-  // If the header size is 0, that means we've come in too early before this
-  // data is set up.
-  // Set ourselves as not valid, and continue.
+  // If the header size is 0, that means we've come in too early before
+  // this data is set up. Set ourselves as not valid, and continue.
   if (header_size == 0 || num_descriptors == 0) {
     m_valid = false;
     return;
@@ -328,12 +333,10 @@
   // uint32_t offset
   // uint32_t flags
   //
-  // Where offset is either 0 - in which case it is unused, or
-  // it is the offset of the vtable code from the beginning of the descriptor
-  // record.
-  // Below, we'll convert that into an absolute code address, since I don't want
-  // to have
-  // to compute it over and over.
+  // Where offset is either 0 - in which case it is unused, or it is the
+  // offset of the vtable code from the beginning of the descriptor
+  // record. Below, we'll convert that into an absolute code address,
+  // since I don't want to have to compute it over and over.
 
   // Ingest the whole descriptor array:
   const lldb::addr_t desc_ptr = m_header_addr + header_size;
@@ -349,8 +352,8 @@
     return;
   }
 
-  // The actual code for the vtables will be laid out consecutively, so I also
-  // compute the start and end of the whole code block.
+  // The actual code for the vtables will be laid out consecutively, so I
+  // also compute the start and end of the whole code block.
 
   offset = 0;
   m_code_start_addr = 0;
@@ -370,10 +373,9 @@
 
     offset = start_offset + descriptor_size;
   }
-  // Finally, a little bird told me that all the vtable code blocks are the same
-  // size.
-  // Let's compute the blocks and if they are all the same add the size to the
-  // code end address:
+  // Finally, a little bird told me that all the vtable code blocks are
+  // the same size. Let's compute the blocks and if they are all the same
+  // add the size to the code end address:
   lldb::addr_t code_size = 0;
   bool all_the_same = true;
   for (size_t i = 0; i < num_descriptors - 1; i++) {
@@ -471,7 +473,8 @@
         if (m_trampoline_header == LLDB_INVALID_ADDRESS)
           return false;
 
-        // Next look up the "changed" symbol and set a breakpoint on that...
+        // Next look up the "changed" symbol and set a breakpoint on
+        // that...
         ConstString changed_name("gdb_objc_trampolines_changed");
         const Symbol *changed_symbol =
             m_objc_module_sp->FindFirstSymbolWithNameAndType(changed_name,
@@ -507,10 +510,9 @@
     lldb::user_id_t break_loc_id) {
   AppleObjCVTables *vtable_handler = (AppleObjCVTables *)baton;
   if (vtable_handler->InitializeVTableSymbols()) {
-    // The Update function is called with the address of an added region.  So we
-    // grab that address, and
-    // feed it into ReadRegions.  Of course, our friend the ABI will get the
-    // values for us.
+    // The Update function is called with the address of an added region.
+    // So we grab that address, and feed it into ReadRegions.  Of course,
+    // our friend the ABI will get the values for us.
     ExecutionContext exe_ctx(context->exe_ctx_ref);
     Process *process = exe_ctx.GetProcessPtr();
     const ABI *abi = process->GetABI().get();
@@ -549,8 +551,7 @@
 
 bool AppleObjCTrampolineHandler::AppleObjCVTables::ReadRegions() {
   // The no argument version reads the start region from the value of the
-  // gdb_regions_header, and
-  // gets started from there.
+  // gdb_regions_header, and gets started from there.
 
   m_regions.clear();
   if (!InitializeVTableSymbols())
@@ -609,7 +610,8 @@
 
 const AppleObjCTrampolineHandler::DispatchFunction
     AppleObjCTrampolineHandler::g_dispatch_functions[] = {
-        // NAME                              STRET  SUPER  SUPER2  FIXUP TYPE
+        // NAME                              STRET  SUPER  SUPER2  FIXUP
+        // TYPE
         {"objc_msgSend", false, false, false, DispatchFunction::eFixUpNone},
         {"objc_msgSend_fixup", false, false, false,
          DispatchFunction::eFixUpToFix},
@@ -694,10 +696,9 @@
 
   // FIXME: Do some kind of logging here.
   if (m_impl_fn_addr == LLDB_INVALID_ADDRESS) {
-    // If we can't even find the ordinary get method implementation function,
-    // then we aren't going to be able to
-    // step through any method dispatches.  Warn to that effect and get out of
-    // here.
+    // If we can't even find the ordinary get method implementation
+    // function, then we aren't going to be able to step through any
+    // method dispatches.  Warn to that effect and get out of here.
     if (process_sp->CanJIT()) {
       process_sp->GetTarget().GetDebugger().GetErrorFile()->Printf(
           "Could not find implementation lookup function \"%s\""
@@ -706,11 +707,11 @@
     }
     return;
   } else if (m_impl_stret_fn_addr == LLDB_INVALID_ADDRESS) {
-    // It there is no stret return lookup function, assume that it is the same
-    // as the straight lookup:
+    // It there is no stret return lookup function, assume that it is the
+    // same as the straight lookup:
     m_impl_stret_fn_addr = m_impl_fn_addr;
-    // Also we will use the version of the lookup code that doesn't rely on the
-    // stret version of the function.
+    // Also we will use the version of the lookup code that doesn't rely
+    // on the stret version of the function.
     m_lookup_implementation_function_code =
         g_lookup_implementation_no_stret_function_code;
   } else {
@@ -718,13 +719,11 @@
         g_lookup_implementation_with_stret_function_code;
   }
 
-  // Look up the addresses for the objc dispatch functions and cache them.  For
-  // now I'm inspecting the symbol
-  // names dynamically to figure out how to dispatch to them.  If it becomes
-  // more complicated than this we can
+  // Look up the addresses for the objc dispatch functions and cache them.
+  // For now I'm inspecting the symbol names dynamically to figure out how
+  // to dispatch to them.  If it becomes more complicated than this we can
   // turn the g_dispatch_functions char * array into a template table, and
-  // populate the DispatchFunction map
-  // from there.
+  // populate the DispatchFunction map from there.
 
   for (size_t i = 0; i != llvm::array_lengthof(g_dispatch_functions); i++) {
     ConstString name_const_str(g_dispatch_functions[i].name);
@@ -732,11 +731,11 @@
         m_objc_module_sp->FindFirstSymbolWithNameAndType(name_const_str,
                                                          eSymbolTypeCode);
     if (msgSend_symbol && msgSend_symbol->ValueIsAddress()) {
-      // FixMe: Make g_dispatch_functions static table of DispatchFunctions, and
-      // have the map be address->index.
-      // Problem is we also need to lookup the dispatch function.  For now we
-      // could have a side table of stret & non-stret
-      // dispatch functions.  If that's as complex as it gets, we're fine.
+      // FixMe: Make g_dispatch_functions static table of
+      // DispatchFunctions, and have the map be address->index. Problem is
+      // we also need to lookup the dispatch function.  For now we could
+      // have a side table of stret & non-stret dispatch functions.  If
+      // that's as complex as it gets, we're fine.
 
       lldb::addr_t sym_addr =
           msgSend_symbol->GetAddressRef().GetOpcodeLoadAddress(target);
@@ -766,7 +765,8 @@
   {
     std::lock_guard<std::mutex> guard(m_impl_function_mutex);
 
-    // First stage is to make the ClangUtility to hold our injected function:
+    // First stage is to make the ClangUtility to hold our injected
+    // function:
 
     if (!m_impl_code.get()) {
       if (m_lookup_implementation_function_code != NULL) {
@@ -797,7 +797,8 @@
         return LLDB_INVALID_ADDRESS;
       }
 
-      // Next make the runner function for our implementation utility function.
+      // Next make the runner function for our implementation utility
+      // function.
       ClangASTContext *clang_ast_context =
           thread.GetProcess()->GetTarget().GetScratchClangASTContext();
       CompilerType clang_void_ptr_type =
@@ -820,11 +821,11 @@
 
   diagnostics.Clear();
 
-  // Now write down the argument values for this particular call.  This looks
-  // like it might be a race condition
-  // if other threads were calling into here, but actually it isn't because we
-  // allocate a new args structure for
-  // this call by passing args_addr = LLDB_INVALID_ADDRESS...
+  // Now write down the argument values for this particular call.  This
+  // looks like it might be a race condition if other threads were calling
+  // into here, but actually it isn't because we allocate a new args
+  // structure for this call by passing args_addr =
+  // LLDB_INVALID_ADDRESS...
 
   if (!impl_function_caller->WriteFunctionArguments(
           exe_ctx, args_addr, dispatch_values, diagnostics)) {
@@ -847,9 +848,9 @@
   DispatchFunction this_dispatch;
   bool found_it = false;
 
-  // First step is to look and see if we are in one of the known ObjC dispatch
-  // functions.  We've already compiled
-  // a table of same, so consult it.
+  // First step is to look and see if we are in one of the known ObjC
+  // dispatch functions.  We've already compiled a table of same, so
+  // consult it.
 
   MsgsendMap::iterator pos;
   pos = m_msgSend_map.find(curr_pc);
@@ -907,9 +908,9 @@
     int sel_index;
 
     // If this is a struct return dispatch, then the first argument is the
-    // return struct pointer, and the object is the second, and the selector is
-    // the third.
-    // Otherwise the object is the first and the selector the second.
+    // return struct pointer, and the object is the second, and the
+    // selector is the third. Otherwise the object is the first and the
+    // selector the second.
     if (this_dispatch.stret_return) {
       obj_index = 1;
       sel_index = 2;
@@ -938,29 +939,26 @@
 
     ExecutionContext exe_ctx(thread.shared_from_this());
     Process *process = exe_ctx.GetProcessPtr();
-    // isa_addr will store the class pointer that the method is being dispatched
-    // to - so either the class
-    // directly or the super class if this is one of the objc_msgSendSuper
-    // flavors.  That's mostly used to
-    // look up the class/selector pair in our cache.
+    // isa_addr will store the class pointer that the method is being
+    // dispatched to - so either the class directly or the super class if
+    // this is one of the objc_msgSendSuper flavors.  That's mostly used
+    // to look up the class/selector pair in our cache.
 
     lldb::addr_t isa_addr = LLDB_INVALID_ADDRESS;
     lldb::addr_t sel_addr =
         argument_values.GetValueAtIndex(sel_index)->GetScalar().ULongLong();
 
-    // Figure out the class this is being dispatched to and see if we've already
-    // cached this method call,
-    // If so we can push a run-to-address plan directly.  Otherwise we have to
-    // figure out where
-    // the implementation lives.
+    // Figure out the class this is being dispatched to and see if we've
+    // already cached this method call, If so we can push a run-to-address
+    // plan directly.  Otherwise we have to figure out where the
+    // implementation lives.
 
     if (this_dispatch.is_super) {
       if (this_dispatch.is_super2) {
-        // In the objc_msgSendSuper2 case, we don't get the object directly, we
-        // get a structure containing
-        // the object and the class to which the super message is being sent.
-        // So we need to dig the super
-        // out of the class and use that.
+        // In the objc_msgSendSuper2 case, we don't get the object
+        // directly, we get a structure containing the object and the
+        // class to which the super message is being sent. So we need to
+        // dig the super out of the class and use that.
 
         Value super_value(*(argument_values.GetValueAtIndex(obj_index)));
         super_value.GetScalar() += process->GetAddressByteSize();
@@ -968,8 +966,8 @@
 
         if (super_value.GetScalar().IsValid()) {
 
-          // isa_value now holds the class pointer.  The second word of the
-          // class pointer is the super-class pointer:
+          // isa_value now holds the class pointer.  The second word of
+          // the class pointer is the super-class pointer:
           super_value.GetScalar() += process->GetAddressByteSize();
           super_value.ResolveValue(&exe_ctx);
           if (super_value.GetScalar().IsValid())
@@ -984,11 +982,10 @@
             log->Printf("Failed to extract the class value from objc_super.");
         }
       } else {
-        // In the objc_msgSendSuper case, we don't get the object directly, we
-        // get a two element structure containing
-        // the object and the super class to which the super message is being
-        // sent.  So the class we want is
-        // the second element of this structure.
+        // In the objc_msgSendSuper case, we don't get the object
+        // directly, we get a two element structure containing the object
+        // and the super class to which the super message is being sent.
+        // So the class we want is the second element of this structure.
 
         Value super_value(*(argument_values.GetValueAtIndex(obj_index)));
         super_value.GetScalar() += process->GetAddressByteSize();
@@ -1002,17 +999,16 @@
         }
       }
     } else {
-      // In the direct dispatch case, the object->isa is the class pointer we
-      // want.
+      // In the direct dispatch case, the object->isa is the class pointer
+      // we want.
 
-      // This is a little cheesy, but since object->isa is the first field,
-      // making the object value a load address value and resolving it will get
-      // the pointer sized data pointed to by that value...
+      // This is a little cheesy, but since object->isa is the first
+      // field, making the object value a load address value and resolving
+      // it will get the pointer sized data pointed to by that value...
 
-      // Note, it isn't a fatal error not to be able to get the address from the
-      // object, since this might
-      // be a "tagged pointer" which isn't a real object, but rather some word
-      // length encoded dingus.
+      // Note, it isn't a fatal error not to be able to get the address
+      // from the object, since this might be a "tagged pointer" which
+      // isn't a real object, but rather some word length encoded dingus.
 
       Value isa_value(*(argument_values.GetValueAtIndex(obj_index)));
 
@@ -1026,8 +1022,8 @@
       }
     }
 
-    // Okay, we've got the address of the class for which we're resolving this,
-    // let's see if it's in our cache:
+    // Okay, we've got the address of the class for which we're resolving
+    // this, let's see if it's in our cache:
     lldb::addr_t impl_addr = LLDB_INVALID_ADDRESS;
 
     if (isa_addr != LLDB_INVALID_ADDRESS) {
@@ -1060,8 +1056,8 @@
       ValueList dispatch_values;
 
       // We've will inject a little function in the target that takes the
-      // object, selector and some flags,
-      // and figures out the implementation.  Looks like:
+      // object, selector and some flags, and figures out the
+      // implementation.  Looks like:
       //      void *__lldb_objc_find_implementation_for_selector (void *object,
       //                                                          void *sel,
       //                                                          int is_stret,
@@ -1080,7 +1076,8 @@
           clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
               lldb::eEncodingSint, 32);
       flag_value.SetValueType(Value::eValueTypeScalar);
-      // flag_value.SetContext (Value::eContextTypeClangType, clang_int_type);
+      // flag_value.SetContext (Value::eContextTypeClangType,
+      // clang_int_type);
       flag_value.SetCompilerType(clang_int_type);
 
       if (this_dispatch.stret_return)
@@ -1126,9 +1123,9 @@
         flag_value.GetScalar() = 0; // FIXME - Set to 0 when debugging is done.
       dispatch_values.PushValue(flag_value);
 
-      // The step through code might have to fill in the cache, so it is not
-      // safe to run only one thread.
-      // So we override the stop_others value passed in to us here:
+      // The step through code might have to fill in the cache, so it is
+      // not safe to run only one thread. So we override the stop_others
+      // value passed in to us here:
       const bool trampoline_stop_others = false;
       ret_plan_sp.reset(new AppleThreadPlanStepThroughObjCTrampoline(
           thread, this, dispatch_values, isa_addr, sel_addr,
Index: source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp
===================================================================
--- source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp
+++ source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp
@@ -60,8 +60,8 @@
   return total;
 }
 
-// as an extension to the published grammar recent runtimes emit structs like
-// this:
+// as an extension to the published grammar recent runtimes emit structs
+// like this:
 // "{CGRect=\"origin\"{CGPoint=\"x\"d\"y\"d}\"size\"{CGSize=\"width\"d\"height\"d}}"
 
 AppleObjCTypeEncodingParser::StructElement::StructElement()
@@ -105,10 +105,10 @@
     return clang::QualType();
   std::string name(ReadStructName(type));
 
-  // We do not handle templated classes/structs at the moment.
-  // If the name has a < in it, we are going to abandon this.
-  // We're still obliged to parse it, so we just set a flag that
-  // means "Don't actually build anything."
+  // We do not handle templated classes/structs at the moment. If the name
+  // has a < in it, we are going to abandon this. We're still obliged to
+  // parse it, so we just set a flag that means "Don't actually build
+  // anything."
 
   const bool is_templated = name.find('<') != std::string::npos;
 
@@ -178,13 +178,11 @@
   return ClangUtil::GetQualType(array_type);
 }
 
-// the runtime can emit these in the form of @"SomeType", giving more specifics
-// this would be interesting for expression parser interop, but since we
-// actually try
-// to avoid exposing the ivar info to the expression evaluator, consume but
-// ignore the type info
-// and always return an 'id'; if anything, dynamic typing will resolve things
-// for us anyway
+// the runtime can emit these in the form of @"SomeType", giving more
+// specifics this would be interesting for expression parser interop, but
+// since we actually try to avoid exposing the ivar info to the expression
+// evaluator, consume but ignore the type info and always return an 'id';
+// if anything, dynamic typing will resolve things for us anyway
 clang::QualType AppleObjCTypeEncodingParser::BuildObjCObjectPointerType(
     clang::ASTContext &ast_ctx, lldb_utility::StringLexer &type,
     bool for_expression) {
@@ -196,25 +194,22 @@
   if (type.NextIf('"')) {
     // We have to be careful here.  We're used to seeing
     //   @"NSString"
-    // but in records it is possible that the string following an @ is the name
-    // of the next field and @ means "id".
-    // This is the case if anything unquoted except for "}", the end of the
-    // type, or another name follows the quoted string.
+    // but in records it is possible that the string following an @ is the
+    // name of the next field and @ means "id". This is the case if
+    // anything unquoted except for "}", the end of the type, or another
+    // name follows the quoted string.
     //
     // E.g.
-    // - @"NSString"@ means "id, followed by a field named NSString of type id"
-    // - @"NSString"} means "a pointer to NSString and the end of the struct"
-    // - @"NSString""nextField" means "a pointer to NSString and a field named
-    // nextField"
-    // - @"NSString" followed by the end of the string means "a pointer to
-    // NSString"
+    // - @"NSString"@ means "id, followed by a field named NSString of
+    // type id" - @"NSString"} means "a pointer to NSString and the end of
+    // the struct" - @"NSString""nextField" means "a pointer to NSString
+    // and a field named nextField" - @"NSString" followed by the end of
+    // the string means "a pointer to NSString"
     //
-    // As a result, the rule is: If we see @ followed by a quoted string, we
-    // peek.
-    // - If we see }, ), ], the end of the string, or a quote ("), the quoted
-    // string is a class name.
-    // - If we see anything else, the quoted string is a field name and we push
-    // it back onto type.
+    // As a result, the rule is: If we see @ followed by a quoted string,
+    // we peek. - If we see }, ), ], the end of the string, or a quote
+    // ("), the quoted string is a class name. - If we see anything else,
+    // the quoted string is a field name and we push it back onto type.
 
     name = ReadQuotedString(type);
 
@@ -259,10 +254,10 @@
     uint32_t num_types =
         decl_vendor->FindDecls(ConstString(name), append, max_matches, decls);
 
-// The user can forward-declare something that has no definition.  The runtime
-// doesn't prohibit this at all.
-// This is a rare and very weird case.  We keep this assert in debug builds so
-// we catch other weird cases.
+// The user can forward-declare something that has no definition.  The
+// runtime doesn't prohibit this at all. This is a rare and very weird
+// case.  We keep this assert in debug builds so we catch other weird
+// cases.
 #ifdef LLDB_CONFIGURATION_DEBUG
     assert(num_types);
 #else
@@ -273,7 +268,8 @@
     return ClangUtil::GetQualType(
         ClangASTContext::GetTypeForDecl(decls[0]).GetPointerType());
   } else {
-    // We're going to resolve this dynamically anyway, so just smile and wave.
+    // We're going to resolve this dynamically anyway, so just smile and
+    // wave.
     return ast_ctx.getObjCIdType();
   }
 }
@@ -315,8 +311,8 @@
   //   if (!lldb_ctx)
   //      return clang::QualType();
   //   return lldb_ctx->GetIntTypeFromBitSize(32, true).GetQualType();
-  // which uses one of the constants if one is available, but we don't think all
-  // this work is necessary.
+  // which uses one of the constants if one is available, but we don't
+  // think all this work is necessary.
   case 'q':
     return ast_ctx.LongLongTy;
   case 'C':
@@ -363,12 +359,11 @@
   }
   case '^': {
     if (!for_expression && type.NextIf('?')) {
-      // if we are not supporting the concept of unknownAny, but what is being
-      // created here is an unknownAny*, then
-      // we can just get away with a void*
-      // this is theoretically wrong (in the same sense as 'theoretically
-      // nothing exists') but is way better than outright failure
-      // in many practical cases
+      // if we are not supporting the concept of unknownAny, but what is
+      // being created here is an unknownAny*, then we can just get away
+      // with a void* this is theoretically wrong (in the same sense as
+      // 'theoretically nothing exists') but is way better than outright
+      // failure in many practical cases
       return ast_ctx.VoidPtrTy;
     } else {
       clang::QualType target_type = BuildType(ast_ctx, type, for_expression);
Index: source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp
===================================================================
--- source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp
+++ source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp
@@ -51,9 +51,9 @@
     ~AppleThreadPlanStepThroughObjCTrampoline() {}
 
 void AppleThreadPlanStepThroughObjCTrampoline::DidPush() {
-  // Setting up the memory space for the called function text might require
-  // allocations,
-  // i.e. a nested function call.  This needs to be done as a PreResumeAction.
+  // Setting up the memory space for the called function text might
+  // require allocations, i.e. a nested function call.  This needs to be
+  // done as a PreResumeAction.
   m_thread.GetProcess()->AddPreResumeAction(PreResumeInitializeFunctionCaller,
                                             (void *)this);
 }
@@ -109,9 +109,9 @@
 bool AppleThreadPlanStepThroughObjCTrampoline::DoPlanExplainsStop(
     Event *event_ptr) {
   // If we get asked to explain the stop it will be because something went
-  // wrong (like the implementation for selector function crashed...  We're
-  // going
-  // to figure out what to do about that, so we do explain the stop.
+  // wrong (like the implementation for selector function crashed...
+  // We're going to figure out what to do about that, so we do explain the
+  // stop.
   return true;
 }
 
@@ -120,8 +120,8 @@
 }
 
 bool AppleThreadPlanStepThroughObjCTrampoline::ShouldStop(Event *event_ptr) {
-  // First stage: we are still handling the "call a function to get the target
-  // of the dispatch"
+  // First stage: we are still handling the "call a function to get the
+  // target of the dispatch"
   if (m_func_sp) {
     if (!m_func_sp->IsPlanComplete()) {
       return false;
@@ -134,9 +134,8 @@
     }
   }
 
-  // Second stage, if all went well with the function calling, then fetch the
-  // target address, and
-  // queue up a "run to that address" plan.
+  // Second stage, if all went well with the function calling, then fetch
+  // the target address, and queue up a "run to that address" plan.
   if (!m_run_to_sp) {
     Value target_addr_value;
     ExecutionContext exc_ctx;
@@ -201,8 +200,8 @@
   return false;
 }
 
-// The base class MischiefManaged does some cleanup - so you have to call it
-// in your MischiefManaged derived class.
+// The base class MischiefManaged does some cleanup - so you have to call
+// it in your MischiefManaged derived class.
 bool AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged() {
   if (IsPlanComplete())
     return true;
Index: source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.cpp
===================================================================
--- source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.cpp
+++ source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.cpp
@@ -37,14 +37,13 @@
 using namespace lldb_renderscript;
 
 // [``slang``](https://android.googlesource.com/platform/frameworks/compile/slang),
-// the compiler frontend for RenderScript embeds an ARM specific triple in IR
-// that is shipped in the app, after
-// generating IR that has some assumptions that an ARM device is the target.
-// As the IR is then compiled on a device of unknown (at time the IR was
-// generated at least) architecture,
-// when calling RenderScript API function as part of debugger expressions, we
-// have to perform a fixup pass that
-// removes those assumptions right before the module is sent to be generated by
+// the compiler frontend for RenderScript embeds an ARM specific triple in
+// IR that is shipped in the app, after generating IR that has some
+// assumptions that an ARM device is the target. As the IR is then
+// compiled on a device of unknown (at time the IR was generated at least)
+// architecture, when calling RenderScript API function as part of
+// debugger expressions, we have to perform a fixup pass that removes
+// those assumptions right before the module is sent to be generated by
 // the llvm backend.
 
 namespace {
@@ -106,11 +105,10 @@
   switch (m_process_ptr->GetTarget().GetArchitecture().GetMachine()) {
   case llvm::Triple::ArchType::x86:
     changed_module |= fixupX86FunctionCalls(module);
-    // For some reason this triple gets totally missed by the backend, and must
-    // be set manually.
-    // There a reference in bcc/Main.cpp about auto feature-detection being
-    // removed from LLVM3.5, but I can't
-    // see that discussion anywhere public.
+    // For some reason this triple gets totally missed by the backend, and
+    // must be set manually. There a reference in bcc/Main.cpp about auto
+    // feature-detection being removed from LLVM3.5, but I can't see that
+    // discussion anywhere public.
     real_triple = "i686--linux-android";
     break;
   case llvm::Triple::ArchType::x86_64:
@@ -118,20 +116,19 @@
     break;
   case llvm::Triple::ArchType::mipsel:
   case llvm::Triple::ArchType::mips64el:
-    // No actual IR fixup pass is needed on MIPS, but the datalayout
-    // and targetmachine do need to be explicitly set.
+    // No actual IR fixup pass is needed on MIPS, but the datalayout and
+    // targetmachine do need to be explicitly set.
 
     // bcc explicitly compiles MIPS code to use the static relocation
-    // model due to an issue with relocations in mclinker.
-    // see libbcc/support/CompilerConfig.cpp for details
+    // model due to an issue with relocations in mclinker. see
+    // libbcc/support/CompilerConfig.cpp for details
     reloc_model = llvm::Reloc::Static;
     changed_module = true;
     break;
   case llvm::Triple::ArchType::arm:
   case llvm::Triple::ArchType::aarch64:
-    // ARM subtargets need no fixup passes as they are the initial target as
-    // generated by the
-    // slang compiler frontend.
+    // ARM subtargets need no fixup passes as they are the initial target
+    // as generated by the slang compiler frontend.
     break;
   default:
     if (log)
@@ -145,9 +142,9 @@
         real_triple, "", "", options, reloc_model);
     assert(target_machine &&
            "failed to identify RenderScriptRuntime target machine");
-    // We've been using a triple and datalayout of some ARM variant all along,
-    // so
-    // we need to let the backend know that this is no longer the case.
+    // We've been using a triple and datalayout of some ARM variant all
+    // along, so we need to let the backend know that this is no longer
+    // the case.
     if (log) {
       log->Printf("%s - Changing RS target triple to '%s'", __FUNCTION__,
                   real_triple.str().c_str());
Index: source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp
===================================================================
--- source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp
+++ source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp
@@ -92,7 +92,8 @@
   }
 
   // Dereference operator returns contents.
-  // Warning: Will assert if not valid so use only when you know data is valid.
+  // Warning: Will assert if not valid so use only when you know data is
+  // valid.
   const type_t &operator*() const {
     assert(valid);
     return data;
@@ -103,8 +104,8 @@
   type_t data;
 };
 
-// ArgItem is used by the GetArgs() function when reading function arguments
-// from the target.
+// ArgItem is used by the GetArgs() function when reading function
+// arguments from the target.
 struct ArgItem {
   enum { ePointer, eInt32, eInt64, eLong, eBool } type;
 
@@ -113,8 +114,8 @@
   explicit operator uint64_t() const { return value; }
 };
 
-// Context structure to be passed into GetArgsXXX(), argument reading functions
-// below.
+// Context structure to be passed into GetArgsXXX(), argument reading
+// functions below.
 struct GetArgsCtx {
   RegisterContext *reg_ctx;
   Process *process;
@@ -206,8 +207,8 @@
       const size_t size = arg_size[arg_list[i].type];
       // read the argument from memory
       arg.value = 0;
-      // note: due to little endian layout reading 4 or 8 bytes will give the
-      // correct value.
+      // note: due to little endian layout reading 4 or 8 bytes will give
+      // the correct value.
       size_t read = ctx.process->ReadMemory(sp, &arg.value, size, err);
       success = (err.Success() && read == size);
       // advance past this argument
@@ -312,7 +313,8 @@
 
   Status err;
 
-  // find offset to arguments on the stack (+16 to skip over a0-a3 shadow space)
+  // find offset to arguments on the stack (+16 to skip over a0-a3 shadow
+  // space)
   uint64_t sp = ctx.reg_ctx->GetSP() + 16;
 
   for (size_t i = 0; i < num_args; ++i) {
@@ -447,12 +449,11 @@
 }
 
 bool ParseCoordinate(llvm::StringRef coord_s, RSCoordinate &coord) {
-  // takes an argument of the form 'num[,num][,num]'.
-  // Where 'coord_s' is a comma separated 1,2 or 3-dimensional coordinate
-  // with the whitespace trimmed.
-  // Missing coordinates are defaulted to zero.
-  // If parsing of any elements fails the contents of &coord are undefined
-  // and `false` is returned, `true` otherwise
+  // takes an argument of the form 'num[,num][,num]'. Where 'coord_s' is a
+  // comma separated 1,2 or 3-dimensional coordinate with the whitespace
+  // trimmed. Missing coordinates are defaulted to zero. If parsing of any
+  // elements fails the contents of &coord are undefined and `false` is
+  // returned, `true` otherwise
 
   RegularExpression regex;
   RegularExpression::Match regex_match(3);
@@ -525,8 +526,8 @@
   empirical_type<lldb::addr_t> script;
 };
 
-// This Element class represents the Element object in RS, defining the type
-// associated with an Allocation.
+// This Element class represents the Element object in RS, defining the
+// type associated with an Allocation.
 struct RenderScriptRuntime::Element {
   // Taken from rsDefines.h
   enum DataKind {
@@ -625,17 +626,18 @@
     }
   };
 
-  // The FileHeader struct specifies the header we use for writing allocations
-  // to a binary file. Our format begins with the ASCII characters "RSAD",
-  // identifying the file as an allocation dump. Member variables dims and
-  // hdr_size are then written consecutively, immediately followed by an
-  // instance of the ElementHeader struct. Because Elements can contain
-  // subelements, there may be more than one instance of the ElementHeader
-  // struct. With this first instance being the root element, and the other
-  // instances being the root's descendants. To identify which instances are an
-  // ElementHeader's children, each struct is immediately followed by a sequence
-  // of consecutive offsets to the start of its child structs. These offsets are
-  // 4 bytes in size, and the 0 offset signifies no more children.
+  // The FileHeader struct specifies the header we use for writing
+  // allocations to a binary file. Our format begins with the ASCII
+  // characters "RSAD", identifying the file as an allocation dump. Member
+  // variables dims and hdr_size are then written consecutively,
+  // immediately followed by an instance of the ElementHeader struct.
+  // Because Elements can contain subelements, there may be more than one
+  // instance of the ElementHeader struct. With this first instance being
+  // the root element, and the other instances being the root's
+  // descendants. To identify which instances are an ElementHeader's
+  // children, each struct is immediately followed by a sequence of
+  // consecutive offsets to the start of its child structs. These offsets
+  // are 4 bytes in size, and the 0 offset signifies no more children.
   struct FileHeader {
     uint8_t ident[4];  // ASCII 'RSAD' identifying the file
     uint32_t dims[3];  // Dimensions
@@ -806,10 +808,10 @@
     return nullptr;
 }
 
-// Callback with a module to search for matching symbols. We first check that
-// the module contains RS kernels. Then look for a symbol which matches our
-// kernel name. The breakpoint address is finally set using the address of this
-// symbol.
+// Callback with a module to search for matching symbols. We first check
+// that the module contains RS kernels. Then look for a symbol which
+// matches our kernel name. The breakpoint address is finally set using
+// the address of this symbol.
 Searcher::CallbackReturn
 RSBreakpointResolver::SearchCallback(SearchFilter &filter,
                                      SymbolContext &context, Address *, bool) {
@@ -818,9 +820,9 @@
   if (!module || !IsRenderScriptScriptModule(module))
     return Searcher::eCallbackReturnContinue;
 
-  // Attempt to set a breakpoint on the kernel name symbol within the module
-  // library. If it's not found, it's likely debug info is unavailable - try to
-  // set a breakpoint on <name>.expand.
+  // Attempt to set a breakpoint on the kernel name symbol within the
+  // module library. If it's not found, it's likely debug info is
+  // unavailable - try to set a breakpoint on <name>.expand.
   const Symbol *kernel_sym =
       module->FindFirstSymbolWithNameAndType(m_kernel_name, eSymbolTypeCode);
   if (!kernel_sym) {
@@ -844,11 +846,10 @@
                                            lldb_private::SymbolContext &context,
                                            Address *, bool) {
   // We need to have access to the list of reductions currently parsed, as
-  // reduce names don't actually exist as
-  // symbols in a module. They are only identifiable by parsing the .rs.info
-  // packet, or finding the expand symbol. We
-  // therefore need access to the list of parsed rs modules to properly resolve
-  // reduction names.
+  // reduce names don't actually exist as symbols in a module. They are
+  // only identifiable by parsing the .rs.info packet, or finding the
+  // expand symbol. We therefore need access to the list of parsed rs
+  // modules to properly resolve reduction names.
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
   ModuleSP module = context.module_sp;
 
@@ -967,8 +968,8 @@
         log->Printf("%s: Placed %sbreakpoint on %s", __FUNCTION__,
                     new_bp ? "new " : "", k.m_name.AsCString());
 
-      // exit after placing the first breakpoint if we do not intend to stop
-      // on all kernels making up this script group
+      // exit after placing the first breakpoint if we do not intend to
+      // stop on all kernels making up this script group
       if (!m_stop_on_all)
         break;
     }
@@ -1345,8 +1346,8 @@
     // calculate offest to allocation pointer
     const addr_t addr = addr_t(args[eRsAIns]) + i * target_ptr_size;
 
-    // Note: due to little endian layout, reading 32bits or 64bits into res
-    // will give the correct results.
+    // Note: due to little endian layout, reading 32bits or 64bits into
+    // res will give the correct results.
     uint64_t result = 0;
     size_t read = m_process->ReadMemory(addr, &result, target_ptr_size, err);
     if (read != target_ptr_size || !err.Success()) {
@@ -1684,15 +1685,16 @@
   const ModuleSP module = rsmodule_sp->m_module;
   const FileSpec &file = module->GetPlatformFileSpec();
 
-  // Iterate over all of the scripts that we currently know of.
-  // Note: We cant push or pop to m_scripts here or it may invalidate rs_script.
+  // Iterate over all of the scripts that we currently know of. Note: We
+  // cant push or pop to m_scripts here or it may invalidate rs_script.
   for (const auto &rs_script : m_scripts) {
     // Extract the expected .so file path for this script.
     std::string shared_lib;
     if (!rs_script->shared_lib.get(shared_lib))
       continue;
 
-    // Only proceed if the module that has loaded corresponds to this script.
+    // Only proceed if the module that has loaded corresponds to this
+    // script.
     if (file.GetFilename() != ConstString(shared_lib.c_str()))
       continue;
 
@@ -1703,7 +1705,8 @@
 
     // If we have a script mapping for the current script.
     if (m_scriptMappings.find(script) != m_scriptMappings.end()) {
-      // if the module we have stored is different to the one we just received.
+      // if the module we have stored is different to the one we just
+      // received.
       if (m_scriptMappings[script] != rsmodule_sp) {
         if (log)
           log->Printf(
@@ -1730,10 +1733,10 @@
   }
 }
 
-// Uses the Target API to evaluate the expression passed as a parameter to the
-// function The result of that expression is returned an unsigned 64 bit int,
-// via the result* parameter. Function returns true on success, and false on
-// failure
+// Uses the Target API to evaluate the expression passed as a parameter to
+// the function The result of that expression is returned an unsigned 64
+// bit int, via the result* parameter. Function returns true on success,
+// and false on failure
 bool RenderScriptRuntime::EvalRSExpression(const char *expr,
                                            StackFrame *frame_ptr,
                                            uint64_t *result) {
@@ -1823,11 +1826,11 @@
        // Type* rsaAllocationGetType(Context*, Allocation*)
        JIT_TEMPLATE_CONTEXT "(void*)rsaAllocationGetType(ctxt, 0x%" PRIx64 ")", // eExprAllocGetType
 
-       // rsaTypeGetNativeData(Context*, Type*, void* typeData, size) Pack the
-       // data in the following way mHal.state.dimX; mHal.state.dimY;
-       // mHal.state.dimZ; mHal.state.lodCount; mHal.state.faces; mElement; into
-       // typeData Need to specify 32 or 64 bit for uint_t since this differs
-       // between devices
+       // rsaTypeGetNativeData(Context*, Type*, void* typeData, size) Pack
+       // the data in the following way mHal.state.dimX; mHal.state.dimY;
+       // mHal.state.dimZ; mHal.state.lodCount; mHal.state.faces;
+       // mElement; into typeData Need to specify 32 or 64 bit for uint_t
+       // since this differs between devices
        JIT_TEMPLATE_CONTEXT
        "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(ctxt"
        ", 0x%" PRIx64 ", data, 6); data[0]", // eExprTypeDimX
@@ -1841,9 +1844,9 @@
        "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(ctxt"
        ", 0x%" PRIx64 ", data, 6); data[5]", // eExprTypeElemPtr
 
-       // rsaElementGetNativeData(Context*, Element*, uint32_t* elemData,size)
-       // Pack mType; mKind; mNormalized; mVectorSize; NumSubElements into
-       // elemData
+       // rsaElementGetNativeData(Context*, Element*, uint32_t*
+       // elemData,size) Pack mType; mKind; mNormalized; mVectorSize;
+       // NumSubElements into elemData
        JIT_TEMPLATE_CONTEXT
        "uint32_t data[5]; (void*)rsaElementGetNativeData(ctxt"
        ", 0x%" PRIx64 ", data, 5); data[0]", // eExprElementType
@@ -1857,10 +1860,10 @@
        "uint32_t data[5]; (void*)rsaElementGetNativeData(ctxt"
        ", 0x%" PRIx64 ", data, 5); data[4]", // eExprElementFieldCount
 
-       // rsaElementGetSubElements(RsContext con, RsElement elem, uintptr_t
-       // *ids, const char **names, size_t *arraySizes, uint32_t dataSize)
-       // Needed for Allocations of structs to gather details about
-       // fields/Subelements Element* of field
+       // rsaElementGetSubElements(RsContext con, RsElement elem,
+       // uintptr_t *ids, const char **names, size_t *arraySizes, uint32_t
+       // dataSize) Needed for Allocations of structs to gather details
+       // about fields/Subelements Element* of field
        JIT_TEMPLATE_CONTEXT "void* ids[%" PRIu32 "]; const char* names[%" PRIu32
        "]; size_t arr_size[%" PRIu32 "];"
        "(void*)rsaElementGetSubElements(ctxt, 0x%" PRIx64
@@ -1882,10 +1885,10 @@
 }
 } // end of the anonymous namespace
 
-// JITs the RS runtime for the internal data pointer of an allocation. Is passed
-// x,y,z coordinates for the pointer to a specific element. Then sets the
-// data_ptr member in Allocation with the result. Returns true on success, false
-// otherwise
+// JITs the RS runtime for the internal data pointer of an allocation. Is
+// passed x,y,z coordinates for the pointer to a specific element. Then
+// sets the data_ptr member in Allocation with the result. Returns true on
+// success, false otherwise
 bool RenderScriptRuntime::JITDataPointer(AllocationDetails *alloc,
                                          StackFrame *frame_ptr, uint32_t x,
                                          uint32_t y, uint32_t z) {
@@ -1922,9 +1925,9 @@
   return true;
 }
 
-// JITs the RS runtime for the internal pointer to the RS Type of an allocation
-// Then sets the type_ptr member in Allocation with the result. Returns true on
-// success, false otherwise
+// JITs the RS runtime for the internal pointer to the RS Type of an
+// allocation Then sets the type_ptr member in Allocation with the result.
+// Returns true on success, false otherwise
 bool RenderScriptRuntime::JITTypePointer(AllocationDetails *alloc,
                                          StackFrame *frame_ptr) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
@@ -1961,8 +1964,8 @@
 }
 
 // JITs the RS runtime for information about the dimensions and type of an
-// allocation Then sets dimension and element_ptr members in Allocation with the
-// result. Returns true on success, false otherwise
+// allocation Then sets dimension and element_ptr members in Allocation
+// with the result. Returns true on success, false otherwise
 bool RenderScriptRuntime::JITTypePacked(AllocationDetails *alloc,
                                         StackFrame *frame_ptr) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
@@ -2023,9 +2026,9 @@
   return true;
 }
 
-// JITs the RS runtime for information about the Element of an allocation Then
-// sets type, type_vec_size, field_count and type_kind members in Element with
-// the result. Returns true on success, false otherwise
+// JITs the RS runtime for information about the Element of an allocation
+// Then sets type, type_vec_size, field_count and type_kind members in
+// Element with the result. Returns true on success, false otherwise
 bool RenderScriptRuntime::JITElementPacked(Element &elem,
                                            const lldb::addr_t context,
                                            StackFrame *frame_ptr) {
@@ -2077,17 +2080,18 @@
                 __FUNCTION__, *elem.type.get(), *elem.type_kind.get(),
                 *elem.type_vec_size.get(), *elem.field_count.get());
 
-  // If this Element has subelements then JIT rsaElementGetSubElements() for
-  // details about its fields
+  // If this Element has subelements then JIT rsaElementGetSubElements()
+  // for details about its fields
   if (*elem.field_count.get() > 0 && !JITSubelements(elem, context, frame_ptr))
     return false;
 
   return true;
 }
 
-// JITs the RS runtime for information about the subelements/fields of a struct
-// allocation This is necessary for infering the struct type so we can pretty
-// print the allocation's contents. Returns true on success, false otherwise
+// JITs the RS runtime for information about the subelements/fields of a
+// struct allocation This is necessary for infering the struct type so we
+// can pretty print the allocation's contents. Returns true on success,
+// false otherwise
 bool RenderScriptRuntime::JITSubelements(Element &elem,
                                          const lldb::addr_t context,
                                          StackFrame *frame_ptr) {
@@ -2172,11 +2176,12 @@
   return true;
 }
 
-// JITs the RS runtime for the address of the last element in the allocation.
-// The `elem_size` parameter represents the size of a single element, including
-// padding. Which is needed as an offset from the last element pointer. Using
-// this offset minus the starting address we can calculate the size of the
-// allocation. Returns true on success, false otherwise
+// JITs the RS runtime for the address of the last element in the
+// allocation. The `elem_size` parameter represents the size of a single
+// element, including padding. Which is needed as an offset from the last
+// element pointer. Using this offset minus the starting address we can
+// calculate the size of the allocation. Returns true on success, false
+// otherwise
 bool RenderScriptRuntime::JITAllocationSize(AllocationDetails *alloc,
                                             StackFrame *frame_ptr) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
@@ -2194,8 +2199,8 @@
   uint32_t dim_z = alloc->dimension.get()->dim_3;
 
   // Our plan of jitting the last element address doesn't seem to work for
-  // struct Allocations` Instead try to infer the size ourselves without any
-  // inter element padding.
+  // struct Allocations` Instead try to infer the size ourselves without
+  // any inter element padding.
   if (alloc->element.children.size() > 0) {
     if (dim_x == 0)
       dim_x = 1;
@@ -2244,10 +2249,9 @@
   return true;
 }
 
-// JITs the RS runtime for information about the stride between rows in the
-// allocation. This is done to detect padding, since allocated memory is 16-byte
-// aligned.
-// Returns true on success, false otherwise
+// JITs the RS runtime for information about the stride between rows in
+// the allocation. This is done to detect padding, since allocated memory
+// is 16-byte aligned. Returns true on success, false otherwise
 bool RenderScriptRuntime::JITAllocationStride(AllocationDetails *alloc,
                                               StackFrame *frame_ptr) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
@@ -2312,10 +2316,10 @@
   return true;
 }
 
-// Function attempts to set the type_name member of the paramaterised Element
-// object.
-// This string should be the name of the struct type the Element represents.
-// We need this string for pretty printing the Element to users.
+// Function attempts to set the type_name member of the paramaterised
+// Element object. This string should be the name of the struct type the
+// Element represents. We need this string for pretty printing the Element
+// to users.
 void RenderScriptRuntime::FindStructTypeName(Element &elem,
                                              StackFrame *frame_ptr) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
@@ -2332,10 +2336,10 @@
     module_sp->m_module->FindGlobalVariables(
         RegularExpression(llvm::StringRef(".")), true, UINT32_MAX, var_list);
 
-  // Iterate over all the global variables looking for one with a matching type
-  // to the Element.
-  // We make the assumption a match exists since there needs to be a global
-  // variable to reflect the struct type back into java host code.
+  // Iterate over all the global variables looking for one with a matching
+  // type to the Element. We make the assumption a match exists since
+  // there needs to be a global variable to reflect the struct type back
+  // into java host code.
   for (uint32_t i = 0; i < var_list.GetSize(); ++i) {
     const VariableSP var_sp(var_list.GetVariableAtIndex(i));
     if (!var_sp)
@@ -2346,16 +2350,16 @@
       continue;
 
     // Find the number of variable fields.
-    // If it has no fields, or more fields than our Element, then it can't be
-    // the struct we're looking for.
-    // Don't check for equality since RS can add extra struct members for
-    // padding.
+    // If it has no fields, or more fields than our Element, then it can't
+    // be the struct we're looking for. Don't check for equality since RS
+    // can add extra struct members for padding.
     size_t num_children = valobj_sp->GetNumChildren();
     if (num_children > elem.children.size() || num_children == 0)
       continue;
 
-    // Iterate over children looking for members with matching field names.
-    // If all the field names match, this is likely the struct we want.
+    // Iterate over children looking for members with matching field
+    // names. If all the field names match, this is likely the struct we
+    // want.
     //   TODO: This could be made more robust by also checking children data
     //   sizes, or array size
     bool found = true;
@@ -2403,9 +2407,9 @@
   }
 }
 
-// Function sets the datum_size member of Element. Representing the size of a
-// single instance including padding.
-// Assumes the relevant allocation information has already been jitted.
+// Function sets the datum_size member of Element. Representing the size
+// of a single instance including padding. Assumes the relevant allocation
+// information has already been jitted.
 void RenderScriptRuntime::SetElementSize(Element &elem) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
   const Element::DataType type = *elem.type.get();
@@ -2446,9 +2450,9 @@
                 data_size + padding);
 }
 
-// Given an allocation, this function copies the allocation contents from device
-// into a buffer on the heap.
-// Returning a shared pointer to the buffer containing the data.
+// Given an allocation, this function copies the allocation contents from
+// device into a buffer on the heap. Returning a shared pointer to the
+// buffer containing the data.
 std::shared_ptr<uint8_t>
 RenderScriptRuntime::GetAllocationData(AllocationDetails *alloc,
                                        StackFrame *frame_ptr) {
@@ -2496,11 +2500,10 @@
   return buffer;
 }
 
-// Function copies data from a binary file into an allocation.
-// There is a header at the start of the file, FileHeader, before the data
-// content itself.
-// Information from this header is used to display warnings to the user about
-// incompatibilities
+// Function copies data from a binary file into an allocation. There is a
+// header at the start of the file, FileHeader, before the data content
+// itself. Information from this header is used to display warnings to the
+// user about incompatibilities
 bool RenderScriptRuntime::LoadAllocation(Stream &strm, const uint32_t alloc_id,
                                          const char *path,
                                          StackFrame *frame_ptr) {
@@ -2580,8 +2583,8 @@
     log->Printf("%s - header type %" PRIu32 ", element size %" PRIu32,
                 __FUNCTION__, root_el_hdr.type, root_el_hdr.element_size);
 
-  // Check if the target allocation and file both have the same number of bytes
-  // for an Element
+  // Check if the target allocation and file both have the same number of
+  // bytes for an Element
   if (*alloc->element.datum_size.get() != root_el_hdr.element_size) {
     strm.Printf("Warning: Mismatched Element sizes - file %" PRIu32
                 " bytes, allocation %" PRIu32 " bytes",
@@ -2597,8 +2600,8 @@
     strm.Printf("Warning: File has unknown allocation type");
     strm.EOL();
   } else if (alloc_type != file_type) {
-    // Enum value isn't monotonous, so doesn't always index RsDataTypeToString
-    // array
+    // Enum value isn't monotonous, so doesn't always index
+    // RsDataTypeToString array
     uint32_t target_type_name_idx = alloc_type;
     uint32_t head_type_name_idx = file_type;
     if (alloc_type >= Element::RS_TYPE_ELEMENT &&
@@ -2630,7 +2633,8 @@
   // Calculate size of allocation data in file
   size_t size = data_sp->GetByteSize() - file_header->hdr_size;
 
-  // Check if the target allocation and file both have the same total data size.
+  // Check if the target allocation and file both have the same total data
+  // size.
   const uint32_t alloc_size = *alloc->size.get();
   if (alloc_size != size) {
     strm.Printf("Warning: Mismatched allocation sizes - file 0x%" PRIx64
@@ -2658,17 +2662,17 @@
   return true;
 }
 
-// Function takes as parameters a byte buffer, which will eventually be written
-// to file as the element header, an offset into that buffer, and an Element
-// that will be saved into the buffer at the parametrised offset.
-// Return value is the new offset after writing the element into the buffer.
-// Elements are saved to the file as the ElementHeader struct followed by
-// offsets to the structs of all the element's children.
+// Function takes as parameters a byte buffer, which will eventually be
+// written to file as the element header, an offset into that buffer, and
+// an Element that will be saved into the buffer at the parametrised
+// offset. Return value is the new offset after writing the element into
+// the buffer. Elements are saved to the file as the ElementHeader struct
+// followed by offsets to the structs of all the element's children.
 size_t RenderScriptRuntime::PopulateElementHeaders(
     const std::shared_ptr<uint8_t> header_buffer, size_t offset,
     const Element &elem) {
-  // File struct for an element header with all the relevant details copied from
-  // elem. We assume members are valid already.
+  // File struct for an element header with all the relevant details
+  // copied from elem. We assume members are valid already.
   AllocationDetails::ElementHeader elem_header;
   elem_header.type = *elem.type.get();
   elem_header.kind = *elem.type_kind.get();
@@ -2678,9 +2682,9 @@
       elem.array_size.isValid() ? *elem.array_size.get() : 0;
   const size_t elem_header_size = sizeof(AllocationDetails::ElementHeader);
 
-  // Copy struct into buffer and advance offset
-  // We assume that header_buffer has been checked for nullptr before this
-  // method is called
+  // Copy struct into buffer and advance offset We assume that
+  // header_buffer has been checked for nullptr before this method is
+  // called
   memcpy(header_buffer.get() + offset, &elem_header, elem_header_size);
   offset += elem_header_size;
 
@@ -2689,8 +2693,8 @@
       offset + ((elem.children.size() + 1) * sizeof(uint32_t));
   for (const RenderScriptRuntime::Element &child : elem.children) {
     // Recursively populate the buffer with the element header structs of
-    // children. Then save the offsets where they were set after the parent
-    // element header.
+    // children. Then save the offsets where they were set after the
+    // parent element header.
     memcpy(header_buffer.get() + offset, &child_offset, sizeof(uint32_t));
     offset += sizeof(uint32_t);
 
@@ -2703,11 +2707,11 @@
   return child_offset;
 }
 
-// Given an Element object this function returns the total size needed in the
-// file header to store the element's details. Taking into account the size of
-// the element header struct, plus the offsets to all the element's children.
-// Function is recursive so that the size of all ancestors is taken into
-// account.
+// Given an Element object this function returns the total size needed in
+// the file header to store the element's details. Taking into account the
+// size of the element header struct, plus the offsets to all the
+// element's children. Function is recursive so that the size of all
+// ancestors is taken into account.
 size_t RenderScriptRuntime::CalculateElementHeaderSize(const Element &elem) {
   // Offsets to children plus zero terminator
   size_t size = (elem.children.size() + 1) * sizeof(uint32_t);
@@ -2721,9 +2725,9 @@
   return size;
 }
 
-// Function copies allocation contents into a binary file. This file can then be
-// loaded later into a different allocation. There is a header, FileHeader,
-// before the allocation data containing meta-data.
+// Function copies allocation contents into a binary file. This file can
+// then be loaded later into a different allocation. There is a header,
+// FileHeader, before the allocation data containing meta-data.
 bool RenderScriptRuntime::SaveAllocation(Stream &strm, const uint32_t alloc_id,
                                          const char *path,
                                          StackFrame *frame_ptr) {
@@ -2852,8 +2856,8 @@
   if (module_sp) {
     for (const auto &rs_module : m_rsmodules) {
       if (rs_module->m_module == module_sp) {
-        // Check if the user has enabled automatically breaking on
-        // all RS kernels.
+        // Check if the user has enabled automatically breaking on all RS
+        // kernels.
         if (m_breakAllKernels)
           BreakOnModuleKernels(rs_module);
 
@@ -2974,12 +2978,11 @@
 bool RSModuleDescriptor::ParseExportReduceCount(llvm::StringRef *lines,
                                                 size_t n_lines) {
   // The list of reduction kernels in the `.rs.info` symbol is of the form
-  // "signature - accumulatordatasize - reduction_name - initializer_name -
-  // accumulator_name - combiner_name -
-  // outconverter_name - halter_name"
-  // Where a function is not explicitly named by the user, or is not generated
-  // by the compiler, it is named "." so the
-  // dash separated list should always be 8 items long
+  // "signature - accumulatordatasize - reduction_name - initializer_name
+  // - accumulator_name - combiner_name - outconverter_name - halter_name"
+  // Where a function is not explicitly named by the user, or is not
+  // generated by the compiler, it is named "." so the dash separated list
+  // should always be 8 items long
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
   // Skip the exportReduceCount line
   ++lines;
@@ -3032,8 +3035,8 @@
   // Skip the versionInfo line
   ++lines;
   for (; n_lines--; ++lines) {
-    // We're only interested in bcc and slang versions, and ignore all other
-    // versionInfo lines
+    // We're only interested in bcc and slang versions, and ignore all
+    // other versionInfo lines
     const auto kv_pair = lines->split(" - ");
     if (kv_pair.first == "slang")
       m_slang_version = kv_pair.second.str();
@@ -3049,8 +3052,8 @@
   ++lines;
   for (; n_lines--; ++lines) {
     uint32_t slot;
-    // `forEach` kernels are listed in the `.rs.info` packet as a "slot - name"
-    // pair per line
+    // `forEach` kernels are listed in the `.rs.info` packet as a "slot -
+    // name" pair per line
     const auto kv_pair = lines->split(" - ");
     if (kv_pair.first.getAsInteger(10, slot))
       return false;
@@ -3068,9 +3071,9 @@
   return true;
 }
 
-// The .rs.info symbol in renderscript modules contains a string which needs to
-// be parsed.
-// The string is basic and is parsed on a line by line basis.
+// The .rs.info symbol in renderscript modules contains a string which
+// needs to be parsed. The string is basic and is parsed on a line by line
+// basis.
 bool RSModuleDescriptor::ParseRSInfo() {
   assert(m_module);
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
@@ -3115,7 +3118,8 @@
     return llvm::StringSwitch<int>(name)
         // The number of visible global variables in the script
         .Case("exportVarCount", eExportVar)
-        // The number of RenderScrip `forEach` kernels __attribute__((kernel))
+        // The number of RenderScrip `forEach` kernels
+        // __attribute__((kernel))
         .Case("exportForEachCount", eExportForEach)
         // The number of generalreductions: This marked in the script by
         // `#pragma reduce()`
@@ -3137,8 +3141,8 @@
     const auto handler = rs_info_handler(key);
     if (handler == -1)
       continue;
-    // getAsInteger returns `true` on an error condition - we're only interested
-    // in numeric fields at the moment
+    // getAsInteger returns `true` on an error condition - we're only
+    // interested in numeric fields at the moment
     uint64_t n_lines;
     if (val.getAsInteger(10, n_lines)) {
       LLDB_LOGV(log, "Failed to parse non-numeric '.rs.info' section {0}",
@@ -3213,9 +3217,9 @@
 
   std::map<addr_t, uint64_t> contextReferences;
 
-  // Iterate over all of the currently discovered scripts.
-  // Note: We cant push or pop from m_scripts inside this loop or it may
-  // invalidate script.
+  // Iterate over all of the currently discovered scripts. Note: We cant
+  // push or pop from m_scripts inside this loop or it may invalidate
+  // script.
   for (const auto &script : m_scripts) {
     if (!script->context.isValid())
       continue;
@@ -3279,8 +3283,8 @@
   return alloc;
 }
 
-// Prints the contents of an allocation to the output stream, which may be a
-// file
+// Prints the contents of an allocation to the output stream, which may be
+// a file
 bool RenderScriptRuntime::DumpAllocation(Stream &strm, StackFrame *frame_ptr,
                                          const uint32_t id) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
@@ -3339,8 +3343,8 @@
     return false;
   }
 
-  // Calculate stride between rows as there may be padding at end of rows since
-  // allocated memory is 16-byte aligned
+  // Calculate stride between rows as there may be padding at end of rows
+  // since allocated memory is 16-byte aligned
   if (!alloc->stride.isValid()) {
     if (alloc->dimension.get()->dim_2 == 0) // We only have one dimension
       alloc->stride = 0;
@@ -3393,15 +3397,15 @@
         if ((type == Element::RS_TYPE_NONE) &&
             (alloc->element.children.size() > 0) &&
             (alloc->element.type_name != Element::GetFallbackStructName())) {
-          // Here we are dumping an Element of struct type.
-          // This is done using expression evaluation with the name of the
-          // struct type and pointer to element.
-          // Don't print the name of the resulting expression, since this will
-          // be '$[0-9]+'
+          // Here we are dumping an Element of struct type. This is done
+          // using expression evaluation with the name of the struct type
+          // and pointer to element. Don't print the name of the resulting
+          // expression, since this will be '$[0-9]+'
           DumpValueObjectOptions expr_options;
           expr_options.SetHideName(true);
 
-          // Setup expression as derefrencing a pointer cast to element address.
+          // Setup expression as derefrencing a pointer cast to element
+          // address.
           char expr_char_buffer[jit_max_expr_size];
           int written =
               snprintf(expr_char_buffer, jit_max_expr_size, "*(%s*) 0x%" PRIx64,
@@ -3435,9 +3439,9 @@
   return true;
 }
 
-// Function recalculates all our cached information about allocations by jitting
-// the RS runtime regarding each allocation we know about. Returns true if all
-// allocations could be recomputed, false otherwise.
+// Function recalculates all our cached information about allocations by
+// jitting the RS runtime regarding each allocation we know about. Returns
+// true if all allocations could be recomputed, false otherwise.
 bool RenderScriptRuntime::RecomputeAllAllocations(Stream &strm,
                                                   StackFrame *frame_ptr) {
   bool success = true;
@@ -3458,9 +3462,10 @@
   return success;
 }
 
-// Prints information regarding currently loaded allocations. These details are
-// gathered by jitting the runtime, which has as latency. Index parameter
-// specifies a single allocation ID to print, or a zero value to print them all
+// Prints information regarding currently loaded allocations. These
+// details are gathered by jitting the runtime, which has as latency.
+// Index parameter specifies a single allocation ID to print, or a zero
+// value to print them all
 void RenderScriptRuntime::ListAllocations(Stream &strm, StackFrame *frame_ptr,
                                           const uint32_t index) {
   strm.Printf("RenderScript Allocations:");
@@ -3571,9 +3576,10 @@
   }
 }
 
-// Method is internally called by the 'kernel breakpoint all' command to enable
-// or disable breaking on all kernels. When do_break is true we want to enable
-// this functionality. When do_break is false we want to disable it.
+// Method is internally called by the 'kernel breakpoint all' command to
+// enable or disable breaking on all kernels. When do_break is true we
+// want to enable this functionality. When do_break is false we want to
+// disable it.
 void RenderScriptRuntime::SetBreakAllKernels(bool do_break, TargetSP target) {
   Log *log(
       GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
@@ -3619,8 +3625,8 @@
   BreakpointSP bp = target.CreateBreakpoint(
       m_filtersp, resolver_sp, false, false, false);
 
-  // Give RS breakpoints a specific name, so the user can manipulate them as a
-  // group.
+  // Give RS breakpoints a specific name, so the user can manipulate them
+  // as a group.
   Status err;
   target.AddNameToBreakpoint(bp, "RenderScriptKernel", err);
   if (err.Fail() && log)
@@ -3649,8 +3655,8 @@
   BreakpointSP bp = target.CreateBreakpoint(
       m_filtersp, resolver_sp, false, false, false);
 
-  // Give RS breakpoints a specific name, so the user can manipulate them as a
-  // group.
+  // Give RS breakpoints a specific name, so the user can manipulate them
+  // as a group.
   Status err;
   target.AddNameToBreakpoint(bp, "RenderScriptReduction", err);
   if (err.Fail() && log)
@@ -3661,8 +3667,9 @@
 }
 
 // Given an expression for a variable this function tries to calculate the
-// variable's value. If this is possible it returns true and sets the uint64_t
-// parameter to the variables unsigned value. Otherwise function returns false.
+// variable's value. If this is possible it returns true and sets the
+// uint64_t parameter to the variables unsigned value. Otherwise function
+// returns false.
 bool RenderScriptRuntime::GetFrameVarAsUnsigned(const StackFrameSP frame_sp,
                                                 const char *var_name,
                                                 uint64_t &val) {
@@ -3696,10 +3703,10 @@
   return true;
 }
 
-// Function attempts to find the current coordinate of a kernel invocation by
-// investigating the values of frame variables in the .expand function. These
-// coordinates are returned via the coord array reference parameter. Returns
-// true if the coordinates could be found, and false otherwise.
+// Function attempts to find the current coordinate of a kernel invocation
+// by investigating the values of frame variables in the .expand function.
+// These coordinates are returned via the coord array reference parameter.
+// Returns true if the coordinates could be found, and false otherwise.
 bool RenderScriptRuntime::GetKernelCoordinate(RSCoordinate &coord,
                                               Thread *thread_ptr) {
   static const char *const x_expr = "rsIndex";
@@ -3743,16 +3750,16 @@
       log->Printf("%s - Found .expand function '%s'", __FUNCTION__,
                   func_name.GetCString());
 
-    // Get values for variables in .expand frame that tell us the current kernel
-    // invocation
+    // Get values for variables in .expand frame that tell us the current
+    // kernel invocation
     uint64_t x, y, z;
     bool found = GetFrameVarAsUnsigned(frame_sp, x_expr, x) &&
                  GetFrameVarAsUnsigned(frame_sp, y_expr, y) &&
                  GetFrameVarAsUnsigned(frame_sp, z_expr, z);
 
     if (found) {
-      // The RenderScript runtime uses uint32_t for these vars. If they're not
-      // within bounds, our frame parsing is garbage
+      // The RenderScript runtime uses uint32_t for these vars. If they're
+      // not within bounds, our frame parsing is garbage
       assert(x <= UINT32_MAX && y <= UINT32_MAX && z <= UINT32_MAX);
       coord.x = (uint32_t)x;
       coord.y = (uint32_t)y;
@@ -3764,13 +3771,12 @@
 }
 
 // Callback when a kernel breakpoint hits and we're looking for a specific
-// coordinate. Baton parameter contains a pointer to the target coordinate we
-// want to break on.
-// Function then checks the .expand frame for the current coordinate and breaks
-// to user if it matches.
-// Parameter 'break_id' is the id of the Breakpoint which made the callback.
-// Parameter 'break_loc_id' is the id for the BreakpointLocation which was hit,
-// a single logical breakpoint can have multiple addresses.
+// coordinate. Baton parameter contains a pointer to the target coordinate
+// we want to break on. Function then checks the .expand frame for the
+// current coordinate and breaks to user if it matches. Parameter
+// 'break_id' is the id of the Breakpoint which made the callback.
+// Parameter 'break_loc_id' is the id for the BreakpointLocation which was
+// hit, a single logical breakpoint can have multiple addresses.
 bool RenderScriptRuntime::KernelBreakpointHit(void *baton,
                                               StoppointCallbackContext *ctx,
                                               user_id_t break_id,
@@ -3835,9 +3841,9 @@
   // Allocate memory for the baton, and copy over coordinate
   RSCoordinate *baton = new RSCoordinate(coord);
 
-  // Create a callback that will be invoked every time the breakpoint is hit.
-  // The baton object passed to the handler is the target coordinate we want to
-  // break on.
+  // Create a callback that will be invoked every time the breakpoint is
+  // hit. The baton object passed to the handler is the target coordinate
+  // we want to break on.
   bp->SetCallback(KernelBreakpointHit, baton, true);
 
   // Store a shared pointer to the baton, so the memory will eventually be
@@ -3845,12 +3851,10 @@
   m_conditional_breaks[bp->GetID()] = std::unique_ptr<RSCoordinate>(baton);
 }
 
-// Tries to set a breakpoint on the start of a kernel, resolved using the kernel
-// name. Argument 'coords', represents a three dimensional coordinate which can
-// be
-// used to specify a single kernel instance to break on. If this is set then we
-// add a callback
-// to the breakpoint.
+// Tries to set a breakpoint on the start of a kernel, resolved using the
+// kernel name. Argument 'coords', represents a three dimensional
+// coordinate which can be used to specify a single kernel instance to
+// break on. If this is set then we add a callback to the breakpoint.
 bool RenderScriptRuntime::PlaceBreakpointOnKernel(TargetSP target,
                                                   Stream &messages,
                                                   const char *name,
@@ -3891,8 +3895,8 @@
   Target &target = GetProcess()->GetTarget();
   BreakpointSP bp = target.CreateBreakpoint(
       m_filtersp, resolver_sp, false, false, false);
-  // Give RS breakpoints a specific name, so the user can manipulate them as a
-  // group.
+  // Give RS breakpoints a specific name, so the user can manipulate them
+  // as a group.
   Status err;
   target.AddNameToBreakpoint(bp, name.GetCString(), err);
   if (err.Fail() && log)
@@ -4120,9 +4124,8 @@
   stream.Printf("outconverter: %s", m_outc_name.AsCString());
   stream.EOL();
   // XXX This is currently unspecified by RenderScript, and unused
-  // stream.Indent();
-  // stream.Printf("halter: '%s'", m_init_name.AsCString());
-  // stream.EOL();
+  // stream.Indent(); stream.Printf("halter: '%s'",
+  // m_init_name.AsCString()); stream.EOL();
   stream.IndentLess();
 }
 
@@ -4265,13 +4268,14 @@
             .Case("combiner", RSReduceBreakpointResolver::eKernelTypeComb)
             .Case("all", RSReduceBreakpointResolver::eKernelTypeAll)
             // Currently not exposed by the runtime
-            // .Case("halter", RSReduceBreakpointResolver::eKernelTypeHalter)
+            // .Case("halter",
+            // RSReduceBreakpointResolver::eKernelTypeHalter)
             .Default(0);
       };
 
       // Matching a comma separated list of known words is fairly
-      // straightforward with PCRE, but we're
-      // using ERE, so we end up with a little ugliness...
+      // straightforward with PCRE, but we're using ERE, so we end up with
+      // a little ugliness...
       RegularExpression::Match match(/* max_matches */ 5);
       RegularExpression match_type_list(
           llvm::StringRef("^([[:alpha:]]+)(,[[:alpha:]]+){0,4}$"));
@@ -4284,7 +4288,8 @@
         return false;
       }
 
-      // splitting on commas is much easier with llvm::StringRef than regex
+      // splitting on commas is much easier with llvm::StringRef than
+      // regex
       llvm::SmallVector<llvm::StringRef, 5> type_names;
       llvm::StringRef(option_val).split(type_names, ',');
 
Index: source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp
===================================================================
--- source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp
+++ source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp
@@ -31,8 +31,8 @@
 namespace {
 
 bool isRSAPICall(llvm::Module &module, llvm::CallInst *call_inst) {
-  // TODO get the list of renderscript modules from lldb and check if
-  // this llvm::Module calls into any of them.
+  // TODO get the list of renderscript modules from lldb and check if this
+  // llvm::Module calls into any of them.
   (void)module;
   const auto func_name = call_inst->getCalledFunction()->getName();
   if (func_name.startswith("llvm") || func_name.startswith("lldb"))
@@ -45,19 +45,16 @@
 }
 
 bool isRSLargeReturnCall(llvm::Module &module, llvm::CallInst *call_inst) {
-  // i686 and x86_64 returns for large vectors in the RenderScript API are not
-  // handled as normal
-  // register pairs, but as a hidden sret type. This is not reflected in the
-  // debug info or mangled
-  // symbol name, and the android ABI for x86 and x86_64, (as well as the
-  // emulators) specifies there is
-  // no AVX, so bcc generates an sret function because we cannot natively return
-  // 256 bit vectors.
-  // This function simply checks whether a function has a > 128bit return type.
-  // It is perhaps an
-  // unreliable heuristic, and relies on bcc not generating AVX code, so if the
-  // android ABI one day
-  // provides for AVX, this function may go out of fashion.
+  // i686 and x86_64 returns for large vectors in the RenderScript API are
+  // not handled as normal register pairs, but as a hidden sret type. This
+  // is not reflected in the debug info or mangled symbol name, and the
+  // android ABI for x86 and x86_64, (as well as the emulators) specifies
+  // there is no AVX, so bcc generates an sret function because we cannot
+  // natively return 256 bit vectors. This function simply checks whether
+  // a function has a > 128bit return type. It is perhaps an unreliable
+  // heuristic, and relies on bcc not generating AVX code, so if the
+  // android ABI one day provides for AVX, this function may go out of
+  // fashion.
   (void)module;
   if (!call_inst || !call_inst->getCalledFunction())
     return false;
@@ -87,13 +84,12 @@
 }
 
 llvm::FunctionType *cloneToStructRetFnTy(llvm::CallInst *call_inst) {
-  // on x86 StructReturn functions return a pointer to the return value, rather
-  // than the return
-  // value itself [ref](http://www.agner.org/optimize/calling_conventions.pdf
-  // section 6).
-  // We create a return type by getting the pointer type of the old return type,
-  // and inserting a new
-  // initial argument of pointer type of the original return type.
+  // on x86 StructReturn functions return a pointer to the return value,
+  // rather than the return value itself
+  // [ref](http://www.agner.org/optimize/calling_conventions.pdf section
+  // 6). We create a return type by getting the pointer type of the old
+  // return type, and inserting a new initial argument of pointer type of
+  // the original return type.
   Log *log(
       GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_EXPRESSIONS));
 
@@ -112,8 +108,7 @@
                                    orig_type->param_end()};
 
   // This may not work if the function is somehow declared void as llvm is
-  // strongly typed
-  // and represents void* with i8*
+  // strongly typed and represents void* with i8*
   assert(!orig_type->getReturnType()->isVoidTy() &&
          "Cannot add StructRet attribute to void function");
   llvm::PointerType *return_type_ptr_type =
@@ -126,8 +121,8 @@
   if (log)
     log->Printf("%s - return type pointer type for StructRet clone @ '0x%p':\n",
                 __FUNCTION__, (void *)return_type_ptr_type);
-  // put the the sret pointer argument in place at the beginning of the argument
-  // list.
+  // put the the sret pointer argument in place at the beginning of the
+  // argument list.
   params.emplace(params.begin(), return_type_ptr_type);
   assert(params.size() == num_params + 1);
   return llvm::FunctionType::get(return_type_ptr_type, params,
@@ -157,11 +152,9 @@
 
 bool fixupX86StructRetCalls(llvm::Module &module) {
   bool changed = false;
-  // changing a basic block while iterating over it seems to have some undefined
-  // behaviour
-  // going on so we find all RS callsites first, then fix them up after
-  // consuming
-  // the iterator.
+  // changing a basic block while iterating over it seems to have some
+  // undefined behaviour going on so we find all RS callsites first, then
+  // fix them up after consuming the iterator.
   std::set<llvm::CallInst *> rs_callsites;
   if (!findRSCallSites(module, rs_callsites, isRSLargeReturnCall))
     return false;
@@ -178,10 +171,9 @@
     std::vector<llvm::Value *> new_call_args(call_site.arg_begin(),
                                              call_site.arg_end());
 
-    // Allocate enough space to store the return value of the original function
-    // we pass a pointer to this allocation as the StructRet param, and then
-    // copy its
-    // value into the lldb return value
+    // Allocate enough space to store the return value of the original
+    // function we pass a pointer to this allocation as the StructRet
+    // param, and then copy its value into the lldb return value
     const llvm::DataLayout &DL = module.getDataLayout();
     llvm::AllocaInst *return_value_alloc = new llvm::AllocaInst(
       func->getReturnType(), DL.getAllocaAddrSpace(), "var_vector_return_alloc",
@@ -222,21 +214,17 @@
 
 bool fixupRSAllocationStructByValCalls(llvm::Module &module) {
   // On x86_64, calls to functions in the RS runtime that take an
-  // `rs_allocation` type argument
-  // are actually handled as by-ref params by bcc, but appear to be passed by
-  // value by lldb (the callsite all use
-  // `struct byval`).
-  // On x86_64 Linux, struct arguments are transferred in registers if the
-  // struct size is no bigger than
-  // 128bits [ref](http://www.agner.org/optimize/calling_conventions.pdf)
-  // section 7.1 "Passing and returning objects"
-  // otherwise passed on the stack.
-  // an object of type `rs_allocation` is actually 256bits, so should be passed
-  // on the stack. However, code generated
-  // by bcc actually treats formal params of type `rs_allocation` as
-  // `rs_allocation *` so we need to convert the
-  // calling convention to pass by reference, and remove any hint of byval from
-  // formal parameters.
+  // `rs_allocation` type argument are actually handled as by-ref params
+  // by bcc, but appear to be passed by value by lldb (the callsite all
+  // use `struct byval`). On x86_64 Linux, struct arguments are
+  // transferred in registers if the struct size is no bigger than 128bits
+  // [ref](http://www.agner.org/optimize/calling_conventions.pdf) section
+  // 7.1 "Passing and returning objects" otherwise passed on the stack. an
+  // object of type `rs_allocation` is actually 256bits, so should be
+  // passed on the stack. However, code generated by bcc actually treats
+  // formal params of type `rs_allocation` as `rs_allocation *` so we need
+  // to convert the calling convention to pass by reference, and remove
+  // any hint of byval from formal parameters.
   bool changed = false;
   std::set<llvm::CallInst *> rs_callsites;
   if (!findRSCallSites(module, rs_callsites, isRSAllocationTyCallSite))
Index: source/Plugins/MemoryHistory/asan/MemoryHistoryASan.cpp
===================================================================
--- source/Plugins/MemoryHistory/asan/MemoryHistoryASan.cpp
+++ source/Plugins/MemoryHistory/asan/MemoryHistoryASan.cpp
@@ -143,8 +143,8 @@
   std::ostringstream thread_name_with_number;
   thread_name_with_number << thread_name << " Thread " << tid;
   history_thread->SetThreadName(thread_name_with_number.str().c_str());
-  // Save this in the Process' ExtendedThreadList so a strong pointer retains
-  // the object
+  // Save this in the Process' ExtendedThreadList so a strong pointer
+  // retains the object
   process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
   result.push_back(new_thread_sp);
 }
Index: source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp
===================================================================
--- source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp
+++ source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp
@@ -90,8 +90,8 @@
   str.assign((const char *)data.GetData(&offset, 16), 16);
   if (str.find("#1/") == 0) {
     // If the name is longer than 16 bytes, or contains an embedded space
-    // then it will use this format where the length of the name is
-    // here and the name characters are after this header.
+    // then it will use this format where the length of the name is here
+    // and the name characters are after this header.
     ar_name_len = strtoul(str.c_str() + 3, &err, 10);
   } else {
     // Strip off any trailing spaces.
@@ -122,7 +122,8 @@
   if (str == ARFMAG) {
     if (ar_name_len > 0) {
       const void *ar_name_ptr = data.GetData(&offset, ar_name_len);
-      // Make sure there was enough data for the string value and bail if not
+      // Make sure there was enough data for the string value and bail if
+      // not
       if (ar_name_ptr == NULL)
         return LLDB_INVALID_OFFSET;
       str.assign((const char *)ar_name_ptr, ar_name_len);
@@ -221,8 +222,8 @@
         // whose modification time doesn't match. It doesn't make sense
         // for us to continue to use this BSD archive since we cache only
         // the object info which consists of file time info and also the
-        // file offset and file size of any contained objects. Since
-        // this information is now out of date, we won't get the correct
+        // file offset and file size of any contained objects. Since this
+        // information is now out of date, we won't get the correct
         // information if we go and extract the file data, so we should
         // remove the old and outdated entry.
         archive_map.erase(pos);
@@ -296,8 +297,8 @@
 
   if (data_sp) {
     // We have data, which means this is the first 512 bytes of the file
-    // Check to see if the magic bytes match and if they do, read the entire
-    // table of contents for the archive and cache it
+    // Check to see if the magic bytes match and if they do, read the
+    // entire table of contents for the archive and cache it
     DataExtractor data;
     data.SetData(data_sp, data_offset, length);
     if (file && data_sp && ObjectContainerBSDArchive::MagicBytesMatch(data)) {
@@ -310,9 +311,9 @@
           static_cast<const void *>(file), static_cast<uint64_t>(file_offset),
           static_cast<uint64_t>(length));
 
-      // Map the entire .a file to be sure that we don't lose any data if the
-      // file gets updated by a new build while this .a file is being used for
-      // debugging
+      // Map the entire .a file to be sure that we don't lose any data if
+      // the file gets updated by a new build while this .a file is being
+      // used for debugging
       DataBufferSP archive_data_sp =
           DataBufferLLVM::CreateSliceFromPath(file->GetPath(), length, file_offset);
       if (!archive_data_sp)
@@ -389,8 +390,8 @@
             m_file, module_sp->GetArchitecture(),
             module_sp->GetModificationTime(), m_offset, m_data);
       }
-      // Clear the m_data that contains the entire archive
-      // data and let our m_archive_sp hold onto the data.
+      // Clear the m_data that contains the entire archive data and let
+      // our m_archive_sp hold onto the data.
       m_data.Clear();
     }
   }
@@ -505,8 +506,8 @@
   const size_t end_count = specs.GetSize();
   size_t num_specs_added = end_count - initial_count;
   if (set_archive_arch && num_specs_added > 0) {
-    // The archive was created but we didn't have an architecture
-    // so we need to set it
+    // The archive was created but we didn't have an architecture so we
+    // need to set it
     for (size_t i = initial_count; i < end_count; ++i) {
       ModuleSpec module_spec;
       if (specs.GetModuleSpecAtIndex(i, module_spec)) {
Index: source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp
===================================================================
--- source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp
+++ source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp
@@ -44,8 +44,9 @@
     const lldb::ModuleSP &module_sp, DataBufferSP &data_sp,
     lldb::offset_t data_offset, const FileSpec *file,
     lldb::offset_t file_offset, lldb::offset_t length) {
-  // We get data when we aren't trying to look for cached container information,
-  // so only try and look for an architecture slice if we get data
+  // We get data when we aren't trying to look for cached container
+  // information, so only try and look for an architecture slice if we get
+  // data
   if (data_sp) {
     DataExtractor data;
     data.SetData(data_sp, data_offset, length);
@@ -81,8 +82,8 @@
 
 bool ObjectContainerUniversalMachO::ParseHeader() {
   bool success = ParseHeader(m_data, m_header, m_fat_archs);
-  // We no longer need any data, we parsed all we needed to parse
-  // and cached it in m_header and m_fat_archs
+  // We no longer need any data, we parsed all we needed to parse and
+  // cached it in m_header and m_fat_archs
   m_data.Clear();
   return success;
 }
@@ -91,10 +92,10 @@
     lldb_private::DataExtractor &data, llvm::MachO::fat_header &header,
     std::vector<llvm::MachO::fat_arch> &fat_archs) {
   bool success = false;
-  // Store the file offset for this universal file as we could have a universal
-  // .o file
-  // in a BSD archive, or be contained in another kind of object.
-  // Universal mach-o files always have their headers in big endian.
+  // Store the file offset for this universal file as we could have a
+  // universal .o file in a BSD archive, or be contained in another kind
+  // of object. Universal mach-o files always have their headers in big
+  // endian.
   lldb::offset_t offset = 0;
   data.SetByteOrder(eByteOrderBig);
   header.magic = data.GetU32(&offset);
@@ -106,9 +107,9 @@
 
     header.nfat_arch = data.GetU32(&offset);
 
-    // Now we should have enough data for all of the fat headers, so lets index
-    // them so we know how many architectures that this universal binary
-    // contains.
+    // Now we should have enough data for all of the fat headers, so lets
+    // index them so we know how many architectures that this universal
+    // binary contains.
     uint32_t arch_idx = 0;
     for (arch_idx = 0; arch_idx < header.nfat_arch; ++arch_idx) {
       if (data.ValidOffsetForDataOfSize(offset, sizeof(fat_arch))) {
@@ -165,8 +166,8 @@
 ObjectContainerUniversalMachO::GetObjectFile(const FileSpec *file) {
   uint32_t arch_idx = 0;
   ArchSpec arch;
-  // If the module hasn't specified an architecture yet, set it to the default
-  // architecture:
+  // If the module hasn't specified an architecture yet, set it to the
+  // default architecture:
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     if (!module_sp->GetArchitecture().IsValid()) {
@@ -184,7 +185,8 @@
         break;
     }
 
-    // Failing an exact match, try to find a compatible Arch of the Target.
+    // Failing an exact match, try to find a compatible Arch of the
+    // Target.
     if (arch_idx >= m_header.nfat_arch) {
       for (arch_idx = 0; arch_idx < m_header.nfat_arch; ++arch_idx) {
         if (GetArchitectureAtIndex(arch_idx, curr_arch) &&
Index: source/Plugins/ObjectFile/ELF/ELFHeader.cpp
===================================================================
--- source/Plugins/ObjectFile/ELF/ELFHeader.cpp
+++ source/Plugins/ObjectFile/ELF/ELFHeader.cpp
@@ -22,8 +22,9 @@
 //------------------------------------------------------------------------------
 // Static utility functions.
 //
-// GetMaxU64 and GetMaxS64 wrap the similarly named methods from DataExtractor
-// with error handling code and provide for parsing a sequence of values.
+// GetMaxU64 and GetMaxS64 wrap the similarly named methods from
+// DataExtractor with error handling code and provide for parsing a
+// sequence of values.
 static bool GetMaxU64(const lldb_private::DataExtractor &data,
                       lldb::offset_t *offset, uint64_t *value,
                       uint32_t byte_size) {
@@ -145,8 +146,8 @@
   if (data.GetU16(offset, &e_ehsize, 6) == NULL)
     return false;
 
-  // Initialize e_phnum, e_shnum, and e_shstrndx with the values
-  // read from the header.
+  // Initialize e_phnum, e_shnum, and e_shstrndx with the values read from
+  // the header.
   e_phnum = e_phnum_hdr;
   e_shnum = e_shnum_hdr;
   e_shstrndx = e_shstrndx_hdr;
Index: source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
===================================================================
--- source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
+++ source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
@@ -241,10 +241,10 @@
     return false;
 
   // The name field is required to be nul-terminated, and n_namesz
-  // includes the terminating nul in observed implementations (contrary
-  // to the ELF-64 spec).  A special case is needed for cores generated
-  // by some older Linux versions, which write a note named "CORE"
-  // without a nul terminator and n_namesz = 4.
+  // includes the terminating nul in observed implementations (contrary to
+  // the ELF-64 spec).  A special case is needed for cores generated by
+  // some older Linux versions, which write a note named "CORE" without a
+  // nul terminator and n_namesz = 4.
   if (n_namesz == 4) {
     char buf[4];
     if (data.ExtractBytes(*offset, 4, data.GetByteOrder(), buf) != 4)
@@ -295,8 +295,9 @@
   uint32_t arch_variant = ArchSpec::eMIPSSubType_unknown;
   uint32_t fileclass = header.e_ident[EI_CLASS];
 
-  // If there aren't any elf flags available (e.g core elf file) then return default 
-  // 32 or 64 bit arch (without any architecture revision) based on object file's class.
+  // If there aren't any elf flags available (e.g core elf file) then
+  // return default  32 or 64 bit arch (without any architecture revision)
+  // based on object file's class.
   if (header.e_type == ET_CORE) {
     switch (fileclass) {
     case llvm::ELF::ELFCLASS32:
@@ -549,8 +550,8 @@
 
       DataExtractor segment_data;
       if (segment_data.SetData(object_data, ph_offset, ph_size) != ph_size) {
-        // The ELF program header contained incorrect data,
-        // probably corefile is incomplete or corrupted.
+        // The ELF program header contained incorrect data, probably
+        // corefile is incomplete or corrupted.
         break;
       }
 
@@ -594,9 +595,9 @@
 }
 
 //
-// WARNING : This function is being deprecated
-// It's functionality has moved to ArchSpec::SetArchitecture
-// This function is only being kept to validate the move.
+// WARNING : This function is being deprecated It's functionality has
+// moved to ArchSpec::SetArchitecture This function is only being kept to
+// validate the move.
 //
 // TODO : Remove this function
 static bool GetOsFromOSABI(unsigned char osabi_byte,
@@ -677,10 +678,11 @@
           data_sp = MapFileData(file, -1, file_offset);
           if (data_sp)
             data.SetData(data_sp);
-          // In case there is header extension in the section #0, the header
-          // we parsed above could have sentinel values for e_phnum, e_shnum,
-          // and e_shstrndx.  In this case we need to reparse the header
-          // with a bigger data source to get the actual values.
+          // In case there is header extension in the section #0, the
+          // header we parsed above could have sentinel values for
+          // e_phnum, e_shnum, and e_shstrndx.  In this case we need to
+          // reparse the header with a bigger data source to get the
+          // actual values.
           if (header.HasHeaderExtension()) {
             lldb::offset_t header_offset = data_offset;
             header.Parse(data, &header_offset);
@@ -717,8 +719,8 @@
 
               // For core files - which usually don't happen to have a
               // gnu_debuglink, and are pretty bulky - calculating whole
-              // contents crc32 would be too much of luxury.  Thus we will need
-              // to fallback to something simpler.
+              // contents crc32 would be too much of luxury.  Thus we will
+              // need to fallback to something simpler.
               if (header.e_type == llvm::ELF::ET_CORE) {
                 ProgramHeaderColl program_headers;
                 GetProgramHeaderInfo(program_headers, data, header);
@@ -735,9 +737,9 @@
               uint32_t uuidt[4] = {gnu_debuglink_crc, 0, 0, 0};
               uuid.SetBytes(uuidt, sizeof(uuidt));
             } else if (core_notes_crc) {
-              // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make
-              // it look different form
-              // .gnu_debuglink crc followed by 4 bytes of note segments crc.
+              // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to
+              // make it look different form .gnu_debuglink crc followed
+              // by 4 bytes of note segments crc.
               uint32_t uuidt[4] = {g_core_uuid_magic, core_notes_crc, 0, 0};
               uuid.SetBytes(uuidt, sizeof(uuidt));
             }
@@ -823,21 +825,19 @@
       size_t sect_idx = 0;
 
       for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
-        // Iterate through the object file sections to find all
-        // of the sections that have SHF_ALLOC in their flag bits.
+        // Iterate through the object file sections to find all of the
+        // sections that have SHF_ALLOC in their flag bits.
         SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
         if (section_sp && section_sp->Test(SHF_ALLOC)) {
           lldb::addr_t load_addr = section_sp->GetFileAddress();
-          // We don't want to update the load address of a section with type
-          // eSectionTypeAbsoluteAddress as they already have the absolute load
-          // address
-          // already specified
+          // We don't want to update the load address of a section with
+          // type eSectionTypeAbsoluteAddress as they already have the
+          // absolute load address already specified
           if (section_sp->GetType() != eSectionTypeAbsoluteAddress)
             load_addr += value;
 
-          // On 32-bit systems the load address have to fit into 4 bytes. The
-          // rest of
-          // the bytes are the overflow from the addition.
+          // On 32-bit systems the load address have to fit into 4 bytes.
+          // The rest of the bytes are the overflow from the addition.
           if (GetAddressByteSize() == 4)
             load_addr &= 0xFFFFFFFF;
 
@@ -869,9 +869,8 @@
   if (!symtab)
     return eAddressClassUnknown;
 
-  // The address class is determined based on the symtab. Ask it from the object
-  // file what
-  // contains the symtab information.
+  // The address class is determined based on the symtab. Ask it from the
+  // object file what contains the symtab information.
   ObjectFile *symtab_objfile = symtab->GetObjectFile();
   if (symtab_objfile != nullptr && symtab_objfile != this)
     return symtab_objfile->GetAddressClass(file_addr);
@@ -907,8 +906,8 @@
 }
 
 bool ObjectFileELF::GetUUID(lldb_private::UUID *uuid) {
-  // Need to parse the section list to get the UUIDs, so make sure that's been
-  // done.
+  // Need to parse the section list to get the UUIDs, so make sure that's
+  // been done.
   if (!ParseSectionHeaders() && GetType() != ObjectFile::eTypeCoreFile)
     return false;
 
@@ -926,8 +925,8 @@
 
     if (core_notes_crc) {
       // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make it
-      // look different form .gnu_debuglink crc - followed by 4 bytes of note
-      // segments crc.
+      // look different form .gnu_debuglink crc - followed by 4 bytes of
+      // note segments crc.
       uint32_t uuidt[4] = {g_core_uuid_magic, core_notes_crc, 0, 0};
       m_uuid.SetBytes(uuidt, sizeof(uuidt));
     }
@@ -1001,8 +1000,8 @@
       addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize();
       return Address(dynsym_section_sp, offset);
     }
-    // MIPS executables uses DT_MIPS_RLD_MAP_REL to support PIE. DT_MIPS_RLD_MAP
-    // exists in non-PIE.
+    // MIPS executables uses DT_MIPS_RLD_MAP_REL to support PIE.
+    // DT_MIPS_RLD_MAP exists in non-PIE.
     else if ((symbol.d_tag == DT_MIPS_RLD_MAP ||
               symbol.d_tag == DT_MIPS_RLD_MAP_REL) &&
              target) {
@@ -1013,7 +1012,8 @@
 
       Status error;
       if (symbol.d_tag == DT_MIPS_RLD_MAP) {
-        // DT_MIPS_RLD_MAP tag stores an absolute address of the debug pointer.
+        // DT_MIPS_RLD_MAP tag stores an absolute address of the debug
+        // pointer.
         Address addr;
         if (target->ReadPointerFromMemory(dyn_base + offset, false, error,
                                           addr))
@@ -1097,8 +1097,8 @@
     const lldb::offset_t section_size = dynsym_data.GetByteSize();
     lldb::offset_t offset = 0;
 
-    // The only type of entries we are concerned with are tagged DT_NEEDED,
-    // yielding the name of a required library.
+    // The only type of entries we are concerned with are tagged
+    // DT_NEEDED, yielding the name of a required library.
     while (offset < section_size) {
       if (!symbol.Parse(dynsym_data, &offset))
         break;
@@ -1235,9 +1235,9 @@
                   ".%" PRIu32 ".%" PRIu32,
                   __FUNCTION__, version_info[1], version_info[2],
                   version_info[3]);
-            // FIXME we have the minimal version number, we could be propagating
-            // that.  version_info[1] = OS Major, version_info[2] = OS Minor,
-            // version_info[3] = Revision.
+            // FIXME we have the minimal version number, we could be
+            // propagating that.  version_info[1] = OS Major,
+            // version_info[2] = OS Minor, version_info[3] = Revision.
             break;
           case LLDB_NT_GNU_ABI_OS_HURD:
             arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS);
@@ -1273,12 +1273,13 @@
         break;
 
       case LLDB_NT_GNU_BUILD_ID_TAG:
-        // Only bother processing this if we don't already have the uuid set.
+        // Only bother processing this if we don't already have the uuid
+        // set.
         if (!uuid.IsValid()) {
-          // 16 bytes is UUID|MD5, 20 bytes is SHA1. Other linkers may produce a
-          // build-id of a different
-          // length. Accept it as long as it's at least 4 bytes as it will be
-          // better than our own crc32.
+          // 16 bytes is UUID|MD5, 20 bytes is SHA1. Other linkers may
+          // produce a build-id of a different length. Accept it as long
+          // as it's at least 4 bytes as it will be better than our own
+          // crc32.
           if (note.n_descsz >= 4 && note.n_descsz <= 20) {
             uint8_t uuidbuf[20];
             if (data.GetU8(&offset, &uuidbuf, note.n_descsz) == nullptr) {
@@ -1294,7 +1295,8 @@
       }
       if (arch_spec.IsMIPS() &&
           arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
-        // The note.n_name == LLDB_NT_OWNER_GNU is valid for Linux platform
+        // The note.n_name == LLDB_NT_OWNER_GNU is valid for Linux
+        // platform
         arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
     }
     // Process NetBSD ELF notes.
@@ -1329,9 +1331,9 @@
       arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS);
       arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::CSR);
 
-      // TODO At some point the description string could be processed.
-      // It could provide a steer towards the kalimba variant which
-      // this ELF targets.
+      // TODO At some point the description string could be processed. It
+      // could provide a steer towards the kalimba variant which this ELF
+      // targets.
       if (note.n_descsz) {
         const char *cstr =
             data.GetCStr(&offset, llvm::alignTo(note.n_descsz, 4));
@@ -1342,40 +1344,34 @@
       arch_spec.GetTriple().setEnvironment(
           llvm::Triple::EnvironmentType::Android);
     } else if (note.n_name == LLDB_NT_OWNER_LINUX) {
-      // This is sometimes found in core files and usually contains extended
-      // register info
+      // This is sometimes found in core files and usually contains
+      // extended register info
       arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
     } else if (note.n_name == LLDB_NT_OWNER_CORE) {
       // Parse the NT_FILE to look for stuff in paths to shared libraries
-      // As the contents look like this in a 64 bit ELF core file:
-      // count     = 0x000000000000000a (10)
-      // page_size = 0x0000000000001000 (4096)
-      // Index start              end                file_ofs           path
-      // ===== ------------------ ------------------ ------------------
-      // -------------------------------------
-      // [  0] 0x0000000000400000 0x0000000000401000 0x0000000000000000
-      // /tmp/a.out
-      // [  1] 0x0000000000600000 0x0000000000601000 0x0000000000000000
-      // /tmp/a.out
-      // [  2] 0x0000000000601000 0x0000000000602000 0x0000000000000001
-      // /tmp/a.out
-      // [  3] 0x00007fa79c9ed000 0x00007fa79cba8000 0x0000000000000000
-      // /lib/x86_64-linux-gnu/libc-2.19.so
-      // [  4] 0x00007fa79cba8000 0x00007fa79cda7000 0x00000000000001bb
-      // /lib/x86_64-linux-gnu/libc-2.19.so
-      // [  5] 0x00007fa79cda7000 0x00007fa79cdab000 0x00000000000001ba
-      // /lib/x86_64-linux-gnu/libc-2.19.so
-      // [  6] 0x00007fa79cdab000 0x00007fa79cdad000 0x00000000000001be
-      // /lib/x86_64-linux-gnu/libc-2.19.so
-      // [  7] 0x00007fa79cdb2000 0x00007fa79cdd5000 0x0000000000000000
-      // /lib/x86_64-linux-gnu/ld-2.19.so
-      // [  8] 0x00007fa79cfd4000 0x00007fa79cfd5000 0x0000000000000022
-      // /lib/x86_64-linux-gnu/ld-2.19.so
-      // [  9] 0x00007fa79cfd5000 0x00007fa79cfd6000 0x0000000000000023
-      // /lib/x86_64-linux-gnu/ld-2.19.so
-      // In the 32 bit ELFs the count, page_size, start, end, file_ofs are
-      // uint32_t
-      // For reference: see readelf source code (in binutils).
+      // As the contents look like this in a 64 bit ELF core file: count
+      // = 0x000000000000000a (10) page_size = 0x0000000000001000 (4096)
+      // Index start              end                file_ofs
+      // path ===== ------------------ ------------------
+      // ------------------ ------------------------------------- [  0]
+      // 0x0000000000400000 0x0000000000401000 0x0000000000000000
+      // /tmp/a.out [  1] 0x0000000000600000 0x0000000000601000
+      // 0x0000000000000000 /tmp/a.out [  2] 0x0000000000601000
+      // 0x0000000000602000 0x0000000000000001 /tmp/a.out [  3]
+      // 0x00007fa79c9ed000 0x00007fa79cba8000 0x0000000000000000
+      // /lib/x86_64-linux-gnu/libc-2.19.so [  4] 0x00007fa79cba8000
+      // 0x00007fa79cda7000 0x00000000000001bb /lib/x86_64-linux-
+      // gnu/libc-2.19.so [  5] 0x00007fa79cda7000 0x00007fa79cdab000
+      // 0x00000000000001ba /lib/x86_64-linux-gnu/libc-2.19.so [  6]
+      // 0x00007fa79cdab000 0x00007fa79cdad000 0x00000000000001be
+      // /lib/x86_64-linux-gnu/libc-2.19.so [  7] 0x00007fa79cdb2000
+      // 0x00007fa79cdd5000 0x0000000000000000 /lib/x86_64-linux-
+      // gnu/ld-2.19.so [  8] 0x00007fa79cfd4000 0x00007fa79cfd5000
+      // 0x0000000000000022 /lib/x86_64-linux-gnu/ld-2.19.so [  9]
+      // 0x00007fa79cfd5000 0x00007fa79cfd6000 0x0000000000000023
+      // /lib/x86_64-linux-gnu/ld-2.19.so In the 32 bit ELFs the count,
+      // page_size, start, end, file_ofs are uint32_t For reference: see
+      // readelf source code (in binutils).
       if (note.n_type == NT_FILE) {
         uint64_t count = data.GetAddress(&offset);
         const char *cstr;
@@ -1399,15 +1395,15 @@
         }
         if (arch_spec.IsMIPS() &&
             arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
-          // In case of MIPSR6, the LLDB_NT_OWNER_GNU note is missing
-          // for some cases (e.g. compile with -nostdlib)
-          // Hence set OS to Linux
+          // In case of MIPSR6, the LLDB_NT_OWNER_GNU note is missing for
+          // some cases (e.g. compile with -nostdlib) Hence set OS to
+          // Linux
           arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 
       }
     }
 
-    // Calculate the offset of the next note just in case "offset" has been used
-    // to poke at the contents of the note data
+    // Calculate the offset of the next note just in case "offset" has
+    // been used to poke at the contents of the note data
     offset = note_offset + note.GetByteSize();
   }
 
@@ -1498,8 +1494,8 @@
   if (!section_headers.empty())
     return section_headers.size();
 
-  // Only initialize the arch_spec to okay defaults if they're not already set.
-  // We'll refine this with note data as we parse the notes.
+  // Only initialize the arch_spec to okay defaults if they're not already
+  // set. We'll refine this with note data as we parse the notes.
   if (arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) {
     llvm::Triple::OSType ostype;
     llvm::Triple::OSType spec_ostype;
@@ -1507,12 +1503,11 @@
     arch_spec.SetArchitecture(eArchTypeELF, header.e_machine, sub_type,
                               header.e_ident[EI_OSABI]);
     
-    // Validate if it is ok to remove GetOsFromOSABI.
-    // Note, that now the OS is determined based on EI_OSABI flag and
-    // the info extracted from ELF notes (see RefineModuleDetailsFromNote).
-    // However in some cases that still might be not enough: for example
-    // a shared library might not have any notes at all
-    // and have EI_OSABI flag set to System V,
+    // Validate if it is ok to remove GetOsFromOSABI. Note, that now the
+    // OS is determined based on EI_OSABI flag and the info extracted from
+    // ELF notes (see RefineModuleDetailsFromNote). However in some cases
+    // that still might be not enough: for example a shared library might
+    // not have any notes at all and have EI_OSABI flag set to System V,
     // as result the OS will be set to UnknownOS.
     GetOsFromOSABI(header.e_ident[EI_OSABI], ostype);
     spec_ostype = arch_spec.GetTriple().getOS();
@@ -1774,9 +1769,9 @@
   if (!m_sections_ap.get() && ParseSectionHeaders()) {
     m_sections_ap.reset(new SectionList());
 
-    // Object files frequently have 0 for every section address, meaning we
-    // need to compute synthetic addresses in order for "file addresses" from
-    // different sections to not overlap
+    // Object files frequently have 0 for every section address, meaning
+    // we need to compute synthetic addresses in order for "file
+    // addresses" from different sections to not overlap
     bool synthaddrs = (CalculateType() == ObjectFile::Type::eTypeObjectFile);
     uint64_t nextaddr = 0;
 
@@ -1842,25 +1837,22 @@
         is_thread_specific = true;
       }
       // .debug_abbrev – Abbreviations used in the .debug_info section
-      // .debug_aranges – Lookup table for mapping addresses to compilation
-      // units
-      // .debug_frame – Call frame information
-      // .debug_info – The core DWARF information section
-      // .debug_line – Line number information
-      // .debug_loc – Location lists used in DW_AT_location attributes
-      // .debug_macinfo – Macro information
-      // .debug_pubnames – Lookup table for mapping object and function names to
-      // compilation units
-      // .debug_pubtypes – Lookup table for mapping type names to compilation
-      // units
-      // .debug_ranges – Address ranges used in DW_AT_ranges attributes
-      // .debug_str – String table used in .debug_info
-      // MISSING? .gnu_debugdata - "mini debuginfo / MiniDebugInfo" section,
+      // .debug_aranges – Lookup table for mapping addresses to
+      // compilation units .debug_frame – Call frame information
+      // .debug_info – The core DWARF information section .debug_line
+      // – Line number information .debug_loc – Location lists used in
+      // DW_AT_location attributes .debug_macinfo – Macro information
+      // .debug_pubnames – Lookup table for mapping object and function
+      // names to compilation units .debug_pubtypes – Lookup table for
+      // mapping type names to compilation units .debug_ranges – Address
+      // ranges used in DW_AT_ranges attributes .debug_str – String
+      // table used in .debug_info MISSING? .gnu_debugdata - "mini
+      // debuginfo / MiniDebugInfo" section,
       // http://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html
       // MISSING? .debug-index -
-      // http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-index?pathrev=144644
-      // MISSING? .debug_types - Type descriptions from DWARF 4? See
-      // http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo
+      // http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-
+      // index?pathrev=144644 MISSING? .debug_types - Type descriptions
+      // from DWARF 4? See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo
       else if (name == g_sect_name_dwarf_debug_abbrev)
         sect_type = eSectionTypeDWARFDebugAbbrev;
       else if (name == g_sect_name_dwarf_debug_addr)
@@ -1939,11 +1931,9 @@
       }
 
       if (eSectionTypeOther == sect_type) {
-        // the kalimba toolchain assumes that ELF section names are free-form.
-        // It does
-        // support linkscripts which (can) give rise to various arbitrarily
-        // named
-        // sections being "Code" or "Data".
+        // the kalimba toolchain assumes that ELF section names are free-
+        // form. It does support linkscripts which (can) give rise to
+        // various arbitrarily named sections being "Code" or "Data".
         sect_type = kalimbaSectionType(m_header, header);
       }
 
@@ -1986,18 +1976,16 @@
     }
   }
 
-  // For eTypeDebugInfo files, the Symbol Vendor will take care of updating the
-  // unified section list.
+  // For eTypeDebugInfo files, the Symbol Vendor will take care of
+  // updating the unified section list.
   if (GetType() != eTypeDebugInfo)
     unified_section_list = *m_sections_ap;
 }
 
 // Find the arm/aarch64 mapping symbol character in the given symbol name.
-// Mapping symbols have the
-// form of "$<char>[.<any>]*". Additionally we recognize cases when the mapping
-// symbol prefixed by
-// an arbitrary string because if a symbol prefix added to each symbol in the
-// object file with
+// Mapping symbols have the form of "$<char>[.<any>]*". Additionally we
+// recognize cases when the mapping symbol prefixed by an arbitrary string
+// because if a symbol prefix added to each symbol in the object file with
 // objcopy then the mapping symbols are also prefixed.
 static char FindArmAarch64MappingSymbol(const char *symbol_name) {
   if (!symbol_name)
@@ -2038,20 +2026,17 @@
   static ConstString bss_section_name(".bss");
   static ConstString opd_section_name(".opd"); // For ppc64
 
-  // On Android the oatdata and the oatexec symbols in the oat and odex files
-  // covers the full
-  // .text section what causes issues with displaying unusable symbol name to
-  // the user and very
-  // slow unwinding speed because the instruction emulation based unwind plans
-  // try to emulate all
-  // instructions in these symbols. Don't add these symbols to the symbol list
-  // as they have no
-  // use for the debugger and they are causing a lot of trouble.
-  // Filtering can't be restricted to Android because this special object file
-  // don't contain the
-  // note section specifying the environment to Android but the custom extension
-  // and file name
-  // makes it highly unlikely that this will collide with anything else.
+  // On Android the oatdata and the oatexec symbols in the oat and odex
+  // files covers the full .text section what causes issues with
+  // displaying unusable symbol name to the user and very slow unwinding
+  // speed because the instruction emulation based unwind plans try to
+  // emulate all instructions in these symbols. Don't add these symbols to
+  // the symbol list as they have no use for the debugger and they are
+  // causing a lot of trouble. Filtering can't be restricted to Android
+  // because this special object file don't contain the note section
+  // specifying the environment to Android but the custom extension and
+  // file name makes it highly unlikely that this will collide with
+  // anything else.
   ConstString file_extension = m_file.GetFileNameExtension();
   bool skip_oatdata_oatexec = file_extension == ConstString("oat") ||
                               file_extension == ConstString("odex");
@@ -2062,9 +2047,9 @@
   SectionList *module_section_list =
       module_sp ? module_sp->GetSectionList() : nullptr;
 
-  // Local cache to avoid doing a FindSectionByName for each symbol. The "const
-  // char*" key must
-  // came from a ConstString object so they can be compared by pointer
+  // Local cache to avoid doing a FindSectionByName for each symbol. The
+  // "const char*" key must came from a ConstString object so they can be
+  // compared by pointer
   std::unordered_map<const char *, lldb::SectionSP> section_name_to_section;
 
   unsigned i;
@@ -2081,9 +2066,9 @@
         (symbol_name == nullptr || symbol_name[0] == '\0'))
       continue;
 
-    // Skipping oatdata and oatexec sections if it is requested. See details
-    // above the
-    // definition of skip_oatdata_oatexec for the reasons.
+    // Skipping oatdata and oatexec sections if it is requested. See
+    // details above the definition of skip_oatdata_oatexec for the
+    // reasons.
     if (skip_oatdata_oatexec && (::strcmp(symbol_name, "oatdata") == 0 ||
                                  ::strcmp(symbol_name, "oatexec") == 0))
       continue;
@@ -2104,8 +2089,8 @@
       break;
     }
 
-    // If a symbol is undefined do not process it further even if it has a STT
-    // type
+    // If a symbol is undefined do not process it further even if it has a
+    // STT type
     if (symbol_type != eSymbolTypeUndefined) {
       switch (symbol.getType()) {
       default:
@@ -2114,27 +2099,29 @@
         break;
 
       case STT_OBJECT:
-        // The symbol is associated with a data object, such as a variable,
-        // an array, etc.
+        // The symbol is associated with a data object, such as a
+        // variable, an array, etc.
         symbol_type = eSymbolTypeData;
         break;
 
       case STT_FUNC:
-        // The symbol is associated with a function or other executable code.
+        // The symbol is associated with a function or other executable
+        // code.
         symbol_type = eSymbolTypeCode;
         break;
 
       case STT_SECTION:
-        // The symbol is associated with a section. Symbol table entries of
-        // this type exist primarily for relocation and normally have
+        // The symbol is associated with a section. Symbol table entries
+        // of this type exist primarily for relocation and normally have
         // STB_LOCAL binding.
         break;
 
       case STT_FILE:
         // Conventionally, the symbol's name gives the name of the source
-        // file associated with the object file. A file symbol has STB_LOCAL
-        // binding, its section index is SHN_ABS, and it precedes the other
-        // STB_LOCAL symbols for the file, if it is present.
+        // file associated with the object file. A file symbol has
+        // STB_LOCAL binding, its section index is SHN_ABS, and it
+        // precedes the other STB_LOCAL symbols for the file, if it is
+        // present.
         symbol_type = eSymbolTypeSourceFile;
         break;
 
@@ -2215,12 +2202,11 @@
       if (arch.GetMachine() == llvm::Triple::arm) {
         if (symbol_type == eSymbolTypeCode) {
           if (symbol.st_value & 1) {
-            // Subtracting 1 from the address effectively unsets
-            // the low order bit, which results in the address
-            // actually pointing to the beginning of the symbol.
-            // This delta will be used below in conjunction with
-            // symbol.st_value to produce the final symbol_value
-            // that we store in the symtab.
+            // Subtracting 1 from the address effectively unsets the low
+            // order bit, which results in the address actually pointing
+            // to the beginning of the symbol. This delta will be used
+            // below in conjunction with symbol.st_value to produce the
+            // final symbol_value that we store in the symtab.
             symbol_value_offset = -1;
             m_address_class_map[symbol.st_value ^ 1] =
                 eAddressClassCodeAlternateISA;
@@ -2267,19 +2253,16 @@
     }
 
     // symbol_value_offset may contain 0 for ARM symbols or -1 for THUMB
-    // symbols. See above for
-    // more details.
+    // symbols. See above for more details.
     uint64_t symbol_value = symbol.st_value + symbol_value_offset;
 
     if (symbol_section_sp == nullptr && section_idx == SHN_ABS &&
         symbol.st_size != 0) {
-      // We don't have a section for a symbol with non-zero size. Create a new
-      // section for it
-      // so the address range covered by the symbol is also covered by the
-      // module (represented
-      // through the section list). It is needed so module lookup for the
-      // addresses covered
-      // by this symbol will be successfull. This case happens for absolute
+      // We don't have a section for a symbol with non-zero size. Create a
+      // new section for it so the address range covered by the symbol is
+      // also covered by the module (represented through the section
+      // list). It is needed so module lookup for the addresses covered by
+      // this symbol will be successfull. This case happens for absolute
       // symbols.
       ConstString fake_section_name(std::string(".absolute.") + symbol_name);
       symbol_section_sp =
@@ -2315,16 +2298,15 @@
 
     llvm::StringRef symbol_ref(symbol_name);
 
-    // Symbol names may contain @VERSION suffixes. Find those and strip them
-    // temporarily.
+    // Symbol names may contain @VERSION suffixes. Find those and strip
+    // them temporarily.
     size_t version_pos = symbol_ref.find('@');
     bool has_suffix = version_pos != llvm::StringRef::npos;
     llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos);
     Mangled mangled(ConstString(symbol_bare), is_mangled);
 
-    // Now append the suffix back to mangled and unmangled names. Only do it if
-    // the
-    // demangling was successful (string is not empty).
+    // Now append the suffix back to mangled and unmangled names. Only do
+    // it if the demangling was successful (string is not empty).
     if (has_suffix) {
       llvm::StringRef suffix = symbol_ref.substr(version_pos);
 
@@ -2339,12 +2321,10 @@
         mangled.SetDemangledName(ConstString((demangled_name + suffix).str()));
     }
 
-    // In ELF all symbol should have a valid size but it is not true for some
-    // function symbols
-    // coming from hand written assembly. As none of the function symbol should
-    // have 0 size we
-    // try to calculate the size for these symbols in the symtab with saying
-    // that their original
+    // In ELF all symbol should have a valid size but it is not true for
+    // some function symbols coming from hand written assembly. As none of
+    // the function symbol should have 0 size we try to calculate the size
+    // for these symbols in the symtab with saying that their original
     // size is not valid.
     bool symbol_size_valid =
         symbol.st_size != 0 || symbol.getType() != STT_FUNC;
@@ -2373,9 +2353,8 @@
                                          user_id_t start_id,
                                          lldb_private::Section *symtab) {
   if (symtab->GetObjectFile() != this) {
-    // If the symbol table section is owned by a different object file, have it
-    // do the
-    // parsing.
+    // If the symbol table section is owned by a different object file,
+    // have it do the parsing.
     ObjectFileELF *obj_file_elf =
         static_cast<ObjectFileELF *>(symtab->GetObjectFile());
     return obj_file_elf->ParseSymbolTable(symbol_table, start_id, symtab);
@@ -2391,8 +2370,8 @@
   assert(symtab_hdr->sh_type == SHT_SYMTAB ||
          symtab_hdr->sh_type == SHT_DYNSYM);
 
-  // sh_link: section header index of associated string table.
-  // Section ID's are ones based.
+  // sh_link: section header index of associated string table. Section
+  // ID's are ones based.
   user_id_t strtab_id = symtab_hdr->sh_link + 1;
   Section *strtab = section_list->FindSectionByID(strtab_id).get();
 
@@ -2477,36 +2456,33 @@
   return 0;
 }
 
-// Returns the size of the normal plt entries and the offset of the first normal
-// plt entry. The
-// 0th entry in the plt table is usually a resolution entry which have different
-// size in some
-// architectures then the rest of the plt entries.
+// Returns the size of the normal plt entries and the offset of the first
+// normal plt entry. The 0th entry in the plt table is usually a
+// resolution entry which have different size in some architectures then
+// the rest of the plt entries.
 static std::pair<uint64_t, uint64_t>
 GetPltEntrySizeAndOffset(const ELFSectionHeader *rel_hdr,
                          const ELFSectionHeader *plt_hdr) {
   const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
 
-  // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 16
-  // bytes.
-  // So round the entsize up by the alignment if addralign is set.
+  // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries
+  // are 16 bytes. So round the entsize up by the alignment if addralign
+  // is set.
   elf_xword plt_entsize =
       plt_hdr->sh_addralign
           ? llvm::alignTo(plt_hdr->sh_entsize, plt_hdr->sh_addralign)
           : plt_hdr->sh_entsize;
 
-  // Some linkers e.g ld for arm, fill plt_hdr->sh_entsize field incorrectly.
-  // PLT entries relocation code in general requires multiple instruction and
-  // should be greater than 4 bytes in most cases. Try to guess correct size
-  // just in case.
+  // Some linkers e.g ld for arm, fill plt_hdr->sh_entsize field
+  // incorrectly. PLT entries relocation code in general requires multiple
+  // instruction and should be greater than 4 bytes in most cases. Try to
+  // guess correct size just in case.
   if (plt_entsize <= 4) {
-    // The linker haven't set the plt_hdr->sh_entsize field. Try to guess the
-    // size of the plt
-    // entries based on the number of entries and the size of the plt section
-    // with the
-    // assumption that the size of the 0th entry is at least as big as the size
-    // of the normal
-    // entries and it isn't much bigger then that.
+    // The linker haven't set the plt_hdr->sh_entsize field. Try to guess
+    // the size of the plt entries based on the number of entries and the
+    // size of the plt section with the assumption that the size of the
+    // 0th entry is at least as big as the size of the normal entries and
+    // it isn't much bigger then that.
     if (plt_hdr->sh_addralign)
       plt_entsize = plt_hdr->sh_size / plt_hdr->sh_addralign /
                     (num_relocations + 1) * plt_hdr->sh_addralign;
@@ -2595,13 +2571,14 @@
   // The link field points to the associated symbol table.
   user_id_t symtab_id = rel_hdr->sh_link;
 
-  // If the link field doesn't point to the appropriate symbol name table then
-  // try to find it by name as some compiler don't fill in the link fields.
+  // If the link field doesn't point to the appropriate symbol name table
+  // then try to find it by name as some compiler don't fill in the link
+  // fields.
   if (!symtab_id)
     symtab_id = GetSectionIndexByName(".dynsym");
 
-  // Get PLT section.  We cannot use rel_hdr->sh_info, since current linkers
-  // point that to the .got.plt or .got section instead of .plt.
+  // Get PLT section.  We cannot use rel_hdr->sh_info, since current
+  // linkers point that to the .got.plt or .got section instead of .plt.
   user_id_t plt_id = GetSectionIndexByName(".plt");
 
   if (!symtab_id || !plt_id)
@@ -2697,7 +2674,8 @@
         // foo.cpp
         // int main(int argc, char **argv) { return 0; }
         //
-        // clang++.exe --target=i686-unknown-linux-gnu -g -c foo.cpp -o foo.o
+        // clang++.exe --target=i686-unknown-linux-gnu -g -c foo.cpp -o
+        // foo.o
         //
         // and running this on the foo.o module.
         assert(false && "unexpected relocation type");
@@ -2798,9 +2776,8 @@
   if (!module_sp)
     return NULL;
 
-  // We always want to use the main object file so we (hopefully) only have one
-  // cached copy
-  // of our symtab, dynamic sections, etc.
+  // We always want to use the main object file so we (hopefully) only
+  // have one cached copy of our symtab, dynamic sections, etc.
   ObjectFile *module_obj_file = module_sp->GetObjectFile();
   if (module_obj_file && module_obj_file != this)
     return module_obj_file->GetSymtab();
@@ -2813,20 +2790,17 @@
     uint64_t symbol_id = 0;
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 
-    // Sharable objects and dynamic executables usually have 2 distinct symbol
-    // tables, one named ".symtab", and the other ".dynsym". The dynsym is a
-    // smaller
-    // version of the symtab that only contains global symbols. The information
-    // found
-    // in the dynsym is therefore also found in the symtab, while the reverse is
-    // not
-    // necessarily true.
+    // Sharable objects and dynamic executables usually have 2 distinct
+    // symbol tables, one named ".symtab", and the other ".dynsym". The
+    // dynsym is a smaller version of the symtab that only contains global
+    // symbols. The information found in the dynsym is therefore also
+    // found in the symtab, while the reverse is not necessarily true.
     Section *symtab =
         section_list->FindSectionByType(eSectionTypeELFSymbolTable, true).get();
     if (!symtab) {
       // The symtab section is non-allocable and can be stripped, so if it
-      // doesn't exist
-      // then use the dynsym section which should always be there.
+      // doesn't exist then use the dynsym section which should always be
+      // there.
       symtab =
           section_list->FindSectionByType(eSectionTypeELFDynamicSymbols, true)
               .get();
@@ -2872,9 +2846,8 @@
       ParseUnwindSymbols(m_symtab_ap.get(), eh_frame);
     }
 
-    // If we still don't have any symtab then create an empty instance to avoid
-    // do the section
-    // lookup next time.
+    // If we still don't have any symtab then create an empty instance to
+    // avoid do the section lookup next time.
     if (m_symtab_ap == nullptr)
       m_symtab_ap.reset(new Symtab(this));
 
@@ -2888,8 +2861,8 @@
 {
   static const char *debug_prefix = ".debug";
 
-  // Set relocated bit so we stop getting called, regardless of
-  // whether we actually relocate.
+  // Set relocated bit so we stop getting called, regardless of whether we
+  // actually relocate.
   section->SetIsRelocated(true);
 
   // We only relocate in ELF relocatable files
@@ -2931,12 +2904,10 @@
   if (!section_list)
     return;
 
-  // First we save the new symbols into a separate list and add them to the
-  // symbol table after
-  // we colleced all symbols we want to add. This is neccessary because adding a
-  // new symbol
-  // invalidates the internal index of the symtab what causing the next lookup
-  // to be slow because
+  // First we save the new symbols into a separate list and add them to
+  // the symbol table after we colleced all symbols we want to add. This
+  // is neccessary because adding a new symbol invalidates the internal
+  // index of the symtab what causing the next lookup to be slow because
   // it have to recalculate the index first.
   std::vector<Symbol> new_symbols;
 
@@ -3296,15 +3267,15 @@
     return false;
 
   if (m_section_headers.empty()) {
-    // Allow elf notes to be parsed which may affect the detected architecture.
+    // Allow elf notes to be parsed which may affect the detected
+    // architecture.
     ParseSectionHeaders();
   }
 
   if (CalculateType() == eTypeCoreFile &&
       m_arch_spec.TripleOSIsUnspecifiedUnknown()) {
     // Core files don't have section headers yet they have PT_NOTE program
-    // headers
-    // that might shed more light on the architecture
+    // headers that might shed more light on the architecture
     if (ParseProgramHeaders()) {
       for (size_t i = 1, count = GetProgramHeaderCount(); i <= count; ++i) {
         const elf::ELFProgramHeader *header = GetProgramHeaderByIndex(i);
@@ -3455,8 +3426,8 @@
 
 std::vector<ObjectFile::LoadableData>
 ObjectFileELF::GetLoadableData(Target &target) {
-  // Create a list of loadable data from loadable segments,
-  // using physical addresses if they aren't all null
+  // Create a list of loadable data from loadable segments, using physical
+  // addresses if they aren't all null
   std::vector<LoadableData> loadables;
   size_t header_count = ParseProgramHeaders();
   bool should_use_paddr = AnySegmentHasPhysicalAddress();
Index: source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp
===================================================================
--- source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp
+++ source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp
@@ -65,8 +65,8 @@
                                           const FileSpec *file,
                                           lldb::offset_t file_offset,
                                           lldb::offset_t length) {
-  // JIT'ed object file is backed by the ObjectFileJITDelegate, never
-  // read from a file
+  // JIT'ed object file is backed by the ObjectFileJITDelegate, never read
+  // from a file
   return NULL;
 }
 
@@ -74,8 +74,8 @@
                                                 DataBufferSP &data_sp,
                                                 const ProcessSP &process_sp,
                                                 lldb::addr_t header_addr) {
-  // JIT'ed object file is backed by the ObjectFileJITDelegate, never
-  // read from memory
+  // JIT'ed object file is backed by the ObjectFileJITDelegate, never read
+  // from memory
   return NULL;
 }
 
@@ -174,8 +174,8 @@
 }
 
 uint32_t ObjectFileJIT::GetDependentModules(FileSpecList &files) {
-  // JIT modules don't have dependencies, but they could
-  // if external functions are called and we know where they are
+  // JIT modules don't have dependencies, but they could if external
+  // functions are called and we know where they are
   files.Clear();
   return 0;
 }
@@ -214,9 +214,8 @@
     const size_t num_sections = section_list->GetSize();
     // "value" is an offset to apply to each top level segment
     for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
-      // Iterate through the object file sections to find all
-      // of the sections that size on disk (to avoid __PAGEZERO)
-      // and load them
+      // Iterate through the object file sections to find all of the
+      // sections that size on disk (to avoid __PAGEZERO) and load them
       SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
       if (section_sp && section_sp->GetFileSize() > 0 &&
           section_sp->IsThreadSpecific() == false) {
Index: source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
===================================================================
--- source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
+++ source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
@@ -69,8 +69,8 @@
 using namespace lldb_private;
 using namespace llvm::MachO;
 
-// Some structure definitions needed for parsing the dyld shared cache files
-// found on iOS devices.
+// Some structure definitions needed for parsing the dyld shared cache
+// files found on iOS devices.
 
 struct lldb_copy_dyld_cache_header_v1 {
   char magic[16];         // e.g. "dyld_v0    i386", "dyld_v1   armv7", etc.
@@ -161,8 +161,7 @@
         case 7:
         case 8:
         case 9:
-          // fancy flavors that encapsulate of the above
-          // flavors...
+          // fancy flavors that encapsulate of the above flavors...
           break;
 
         default:
@@ -393,8 +392,7 @@
         case 7:
         case 8:
         case 9:
-          // fancy flavors that encapsulate of the above
-          // flavors...
+          // fancy flavors that encapsulate of the above flavors...
           break;
 
         default:
@@ -517,8 +515,8 @@
         }
 
         // Note that gpr.cpsr is also copied by the above loop; this loop
-        // technically extends
-        // one element past the end of the gpr.r[] array.
+        // technically extends one element past the end of the gpr.r[]
+        // array.
 
         SetError(GPRRegSet, Read, 0);
         offset = next_thread_state;
@@ -669,8 +667,8 @@
       lldb::offset_t next_thread_state = offset + (count * 4);
       switch (flavor) {
       case GPRRegSet:
-        // x0-x29 + fp + lr + sp + pc (== 33 64-bit registers) plus cpsr (1
-        // 32-bit register)
+        // x0-x29 + fp + lr + sp + pc (== 33 64-bit registers) plus cpsr
+        // (1 32-bit register)
         if (count >= (33 * 2) + 1) {
           for (uint32_t i = 0; i < 29; ++i)
             gpr.x[i] = data.GetU64(&offset);
@@ -1123,7 +1121,8 @@
               data_sp =
                   ReadMemory(process_sp, m_memory_addr, header_and_lc_size);
             } else {
-              // Read in all only the load command data from the file on disk
+              // Read in all only the load command data from the file on
+              // disk
               data_sp = MapFileData(m_file, header_and_lc_size, m_file_offset);
               if (data_sp->GetByteSize() != header_and_lc_size)
                 return false;
@@ -1242,8 +1241,8 @@
       case eSymbolTypeTrampoline:
       case eSymbolTypeResolver:
         if (m_header.cputype == llvm::MachO::CPU_TYPE_ARM) {
-          // For ARM we have a bit in the n_desc field of the symbol
-          // that tells us ARM/Thumb which is bit 0x0008.
+          // For ARM we have a bit in the n_desc field of the symbol that
+          // tells us ARM/Thumb which is bit 0x0008.
           if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB)
             return eAddressClassCodeAlternateISA;
         }
@@ -1335,8 +1334,8 @@
           if (m_data.GetU32(&offset, &m_dysymtab.ilocalsym,
                             (sizeof(m_dysymtab) / sizeof(uint32_t)) - 2) ==
               NULL) {
-            // Clear m_dysymtab if we were unable to read all items from the
-            // load command
+            // Clear m_dysymtab if we were unable to read all items from
+            // the load command
             ::memset(&m_dysymtab, 0, sizeof(m_dysymtab));
           }
         }
@@ -1359,8 +1358,8 @@
     if (m_data.GetU32(&offset, &encryption_cmd, 2) == NULL)
       break;
 
-    // LC_ENCRYPTION_INFO and LC_ENCRYPTION_INFO_64 have the same sizes for
-    // the 3 fields we care about, so treat them the same.
+    // LC_ENCRYPTION_INFO and LC_ENCRYPTION_INFO_64 have the same sizes
+    // for the 3 fields we care about, so treat them the same.
     if (encryption_cmd.cmd == LC_ENCRYPTION_INFO ||
         encryption_cmd.cmd == LC_ENCRYPTION_INFO_64) {
       if (m_data.GetU32(&offset, &encryption_cmd.cryptoff, 3)) {
@@ -1384,12 +1383,12 @@
     return;
 
   if (seg_cmd.fileoff > m_length) {
-    // We have a load command that says it extends past the end of the file.
-    // This is likely a corrupt file.  We don't have any way to return an error
-    // condition here (this method was likely invoked from something like
-    // ObjectFile::GetSectionList()), so we just null out the section contents,
-    // and dump a message to stdout.  The most common case here is core file
-    // debugging with a truncated file.
+    // We have a load command that says it extends past the end of the
+    // file. This is likely a corrupt file.  We don't have any way to
+    // return an error condition here (this method was likely invoked from
+    // something like ObjectFile::GetSectionList()), so we just null out
+    // the section contents, and dump a message to stdout.  The most
+    // common case here is core file debugging with a truncated file.
     const char *lc_segment_name =
         seg_cmd.cmd == LC_SEGMENT_64 ? "LC_SEGMENT_64" : "LC_SEGMENT";
     GetModule()->ReportWarning(
@@ -1403,12 +1402,12 @@
   }
 
   if (seg_cmd.fileoff + seg_cmd.filesize > m_length) {
-    // We have a load command that says it extends past the end of the file.
-    // This is likely a corrupt file.  We don't have any way to return an error
-    // condition here (this method was likely invoked from something like
-    // ObjectFile::GetSectionList()), so we just null out the section contents,
-    // and dump a message to stdout.  The most common case here is core file
-    // debugging with a truncated file.
+    // We have a load command that says it extends past the end of the
+    // file. This is likely a corrupt file.  We don't have any way to
+    // return an error condition here (this method was likely invoked from
+    // something like ObjectFile::GetSectionList()), so we just null out
+    // the section contents, and dump a message to stdout.  The most
+    // common case here is core file debugging with a truncated file.
     const char *lc_segment_name =
         seg_cmd.cmd == LC_SEGMENT_64 ? "LC_SEGMENT_64" : "LC_SEGMENT";
     GetModule()->ReportWarning(
@@ -1626,12 +1625,12 @@
   const bool segment_is_encrypted =
       (load_cmd.flags & SG_PROTECTED_VERSION_1) != 0;
 
-  // Keep a list of mach segments around in case we need to
-  // get at data that isn't stored in the abstracted Sections.
+  // Keep a list of mach segments around in case we need to get at data
+  // that isn't stored in the abstracted Sections.
   m_mach_segments.push_back(load_cmd);
 
-  // Use a segment ID of the segment index shifted left by 8 so they
-  // never conflict with any of the sections.
+  // Use a segment ID of the segment index shifted left by 8 so they never
+  // conflict with any of the sections.
   SectionSP segment_sp;
   if (add_section && (const_segname || is_core)) {
     segment_sp.reset(new Section(
@@ -1639,9 +1638,8 @@
         this,      // Object file to which this sections belongs
         ++context.NextSegmentIdx
             << 8, // Section ID is the 1 based segment index
-        // shifted right by 8 bits as not to collide
-        // with any of the 256 section IDs that are
-        // possible
+        // shifted right by 8 bits as not to collide with any of the 256
+        // section IDs that are possible
         const_segname,         // Name of this section
         eSectionTypeContainer, // This section is a container of other
         // sections.
@@ -1664,27 +1662,25 @@
     if (is_dsym && unified_section_sp->GetFileAddress() != load_cmd.vmaddr) {
       // Check to see if the module was read from memory?
       if (module_sp->GetObjectFile()->GetHeaderAddress().IsValid()) {
-        // We have a module that is in memory and needs to have its
-        // file address adjusted. We need to do this because when we
-        // load a file from memory, its addresses will be slid already,
-        // yet the addresses in the new symbol file will still be
-        // unslid.  Since everything is stored as section offset, this
-        // shouldn't cause any problems.
-
-        // Make sure we've parsed the symbol table from the
-        // ObjectFile before we go around changing its Sections.
+        // We have a module that is in memory and needs to have its file
+        // address adjusted. We need to do this because when we load a
+        // file from memory, its addresses will be slid already, yet the
+        // addresses in the new symbol file will still be unslid.  Since
+        // everything is stored as section offset, this shouldn't cause
+        // any problems.
+
+        // Make sure we've parsed the symbol table from the ObjectFile
+        // before we go around changing its Sections.
         module_sp->GetObjectFile()->GetSymtab();
-        // eh_frame would present the same problems but we parse that
-        // on a per-function basis as-needed so it's more difficult to
-        // remove its use of the Sections.  Realistically, the
-        // environments where this code path will be taken will not
-        // have eh_frame sections.
+        // eh_frame would present the same problems but we parse that on a
+        // per-function basis as-needed so it's more difficult to remove
+        // its use of the Sections.  Realistically, the environments where
+        // this code path will be taken will not have eh_frame sections.
 
         unified_section_sp->SetFileAddress(load_cmd.vmaddr);
 
-        // Notify the module that the section addresses have been
-        // changed once we're done so any file-address caches can be
-        // updated.
+        // Notify the module that the section addresses have been changed
+        // once we're done so any file-address caches can be updated.
         context.FileAddressesChanged = true;
       }
     }
@@ -1693,8 +1689,8 @@
 
   struct section_64 sect64;
   ::memset(&sect64, 0, sizeof(sect64));
-  // Push a section into our mach sections for the section at
-  // index zero (NO_SECT) if we don't have any mach sections yet...
+  // Push a section into our mach sections for the section at index zero
+  // (NO_SECT) if we don't have any mach sections yet...
   if (m_mach_sections.empty())
     m_mach_sections.push_back(sect64);
   uint32_t segment_sect_idx;
@@ -1715,8 +1711,8 @@
     if (m_data.GetU32(&offset, &sect64.offset, num_u32s) == NULL)
       break;
 
-    // Keep a list of mach sections around in case we need to
-    // get at data that isn't stored in the abstracted Sections.
+    // Keep a list of mach sections around in case we need to get at data
+    // that isn't stored in the abstracted Sections.
     m_mach_sections.push_back(sect64);
 
     if (add_section) {
@@ -1727,9 +1723,9 @@
         // We have a segment with no name so we need to conjure up
         // segments that correspond to the section's segname if there
         // isn't already such a section. If there is such a section, we
-        // resize the section so that it spans all sections.  We also
-        // mark these sections as fake so address matches don't hit if
-        // they land in the gaps between the child sections.
+        // resize the section so that it spans all sections.  We also mark
+        // these sections as fake so address matches don't hit if they
+        // land in the gaps between the child sections.
         const_segname.SetTrimmedCStringWithLength(sect64.segname,
                                                   sizeof(sect64.segname));
         segment_sp = context.UnifiedList.FindSectionByName(const_segname);
@@ -1750,8 +1746,7 @@
               segment->SetByteSize(new_seg_byte_size);
           } else {
             // We need to change the base address of the segment and
-            // adjust the child section offsets for all existing
-            // children.
+            // adjust the child section offsets for all existing children.
             const lldb::addr_t slide_amount =
                 sect64_min_addr - curr_seg_min_addr;
             segment->Slide(slide_amount, false);
@@ -1904,9 +1899,9 @@
 public:
   MachSymtabSectionInfo(SectionList *section_list)
       : m_section_list(section_list), m_section_infos() {
-    // Get the number of sections down to a depth of 1 to include
-    // all segments and their sections, but no other sections that
-    // may be added for debug map or
+    // Get the number of sections down to a depth of 1 to include all
+    // segments and their sections, but no other sections that may be
+    // added for debug map or
     m_section_infos.resize(section_list->GetNumSections(1));
   }
 
@@ -2179,8 +2174,8 @@
       const char *path = m_data.PeekCStr(name_offset);
       if (path) {
         FileSpec file_spec(path, false);
-        // Strip the path if there is @rpath, @executable, etc so we just use
-        // the basename
+        // Strip the path if there is @rpath, @executable, etc so we just
+        // use the basename
         if (path[0] == '@')
           file_spec.GetDirectory().Clear();
 
@@ -2250,10 +2245,9 @@
             linkedit_section_sp->GetLoadBaseAddress(&target);
         if (linkedit_load_addr == LLDB_INVALID_ADDRESS) {
           // We might be trying to access the symbol table before the
-          // __LINKEDIT's load
-          // address has been set in the target. We can't fail to read the
-          // symbol table,
-          // so calculate the right address manually
+          // __LINKEDIT's load address has been set in the target. We
+          // can't fail to read the symbol table, so calculate the right
+          // address manually
           linkedit_load_addr = CalculateSectionLoadAddressForMemoryImage(
               m_memory_addr, GetMachHeaderSection(), linkedit_section_sp.get());
         }
@@ -2274,20 +2268,20 @@
             process->GetAddressByteSize() == sizeof(void *)) {
           // This mach-o memory file is in the dyld shared cache. If this
           // program is not remote and this is iOS, then this process will
-          // share the same shared cache as the process we are debugging and
-          // we can read the entire __LINKEDIT from the address space in this
-          // process. This is a needed optimization that is used for local iOS
-          // debugging only since all shared libraries in the shared cache do
-          // not have corresponding files that exist in the file system of the
-          // device. They have been combined into a single file. This means we
-          // always have to load these files from memory. All of the symbol and
-          // string tables from all of the __LINKEDIT sections from the shared
-          // libraries in the shared cache have been merged into a single large
-          // symbol and string table. Reading all of this symbol and string
-          // table
-          // data across can slow down debug launch times, so we optimize this
-          // by
-          // reading the memory for the __LINKEDIT section from this process.
+          // share the same shared cache as the process we are debugging
+          // and we can read the entire __LINKEDIT from the address space
+          // in this process. This is a needed optimization that is used
+          // for local iOS debugging only since all shared libraries in
+          // the shared cache do not have corresponding files that exist
+          // in the file system of the device. They have been combined
+          // into a single file. This means we always have to load these
+          // files from memory. All of the symbol and string tables from
+          // all of the __LINKEDIT sections from the shared libraries in
+          // the shared cache have been merged into a single large symbol
+          // and string table. Reading all of this symbol and string table
+          // data across can slow down debug launch times, so we optimize
+          // this by reading the memory for the __LINKEDIT section from
+          // this process.
 
           UUID lldb_shared_cache(GetLLDBSharedCacheUUID());
           UUID process_shared_cache(GetProcessSharedCacheUUID(process));
@@ -2322,12 +2316,11 @@
 #endif
 
         if (!data_was_read) {
-          // Always load dyld - the dynamic linker - from memory if we didn't
-          // find a binary anywhere else.
-          // lldb will not register dylib/framework/bundle loads/unloads if we
-          // don't have the dyld symbols,
-          // we force dyld to load from memory despite the user's
-          // target.memory-module-load-level setting.
+          // Always load dyld - the dynamic linker - from memory if we
+          // didn't find a binary anywhere else. lldb will not register
+          // dylib/framework/bundle loads/unloads if we don't have the
+          // dyld symbols, we force dyld to load from memory despite the
+          // user's target.memory-module-load-level setting.
           if (memory_module_load_level == eMemoryModuleLoadLevelComplete ||
               m_header.filetype == llvm::MachO::MH_DYLINKER) {
             DataBufferSP nlist_data_sp(
@@ -2335,13 +2328,11 @@
             if (nlist_data_sp)
               nlist_data.SetData(nlist_data_sp, 0,
                                  nlist_data_sp->GetByteSize());
-            // Load strings individually from memory when loading from memory
-            // since shared cache
-            // string tables contain strings for all symbols from all shared
-            // cached libraries
-            // DataBufferSP strtab_data_sp (ReadMemory (process_sp, strtab_addr,
-            // strtab_data_byte_size));
-            // if (strtab_data_sp)
+            // Load strings individually from memory when loading from
+            // memory since shared cache string tables contain strings for
+            // all symbols from all shared cached libraries DataBufferSP
+            // strtab_data_sp (ReadMemory (process_sp, strtab_addr,
+            // strtab_data_byte_size)); if (strtab_data_sp)
             //    strtab_data.SetData (strtab_data_sp, 0,
             //    strtab_data_sp->GetByteSize());
             if (m_dysymtab.nindirectsyms != 0) {
@@ -2443,11 +2434,10 @@
     const bool is_arm = (m_header.cputype == llvm::MachO::CPU_TYPE_ARM);
 
     // lldb works best if it knows the start address of all functions in a
-    // module.
-    // Linker symbols or debug info are normally the best source of information
-    // for start addr / size but
-    // they may be stripped in a released binary.
-    // Two additional sources of information exist in Mach-O binaries:
+    // module. Linker symbols or debug info are normally the best source
+    // of information for start addr / size but they may be stripped in a
+    // released binary. Two additional sources of information exist in
+    // Mach-O binaries:
     //    LC_FUNCTION_STARTS - a list of ULEB128 encoded offsets of each
     //    function's start address in the
     //                         binary, relative to the text section.
@@ -2471,13 +2461,11 @@
         function_starts.Append(function_start_entry);
       }
     } else {
-      // If m_type is eTypeDebugInfo, then this is a dSYM - it will have the
-      // load command claiming an eh_frame
-      // but it doesn't actually have the eh_frame content.  And if we have a
-      // dSYM, we don't need to do any
-      // of this fill-in-the-missing-symbols works anyway - the debug info
-      // should give us all the functions in
-      // the module.
+      // If m_type is eTypeDebugInfo, then this is a dSYM - it will have
+      // the load command claiming an eh_frame but it doesn't actually
+      // have the eh_frame content.  And if we have a dSYM, we don't need
+      // to do any of this fill-in-the-missing-symbols works anyway - the
+      // debug info should give us all the functions in the module.
       if (text_section_sp.get() && eh_frame_section_sp.get() &&
           m_type != eTypeDebugInfo) {
         DWARFCallFrameInfo eh_frame(*this, eh_frame_section_sp,
@@ -2500,19 +2488,16 @@
 
     const size_t function_starts_count = function_starts.GetSize();
 
-    // For user process binaries (executables, dylibs, frameworks, bundles), if
-    // we don't have
-    // LC_FUNCTION_STARTS/eh_frame section in this binary, we're going to assume
-    // the binary
-    // has been stripped.  Don't allow assembly language instruction emulation
-    // because we don't
-    // know proper function start boundaries.
+    // For user process binaries (executables, dylibs, frameworks,
+    // bundles), if we don't have LC_FUNCTION_STARTS/eh_frame section in
+    // this binary, we're going to assume the binary has been stripped.
+    // Don't allow assembly language instruction emulation because we
+    // don't know proper function start boundaries.
     //
     // For all other types of binaries (kernels, stand-alone bare board
-    // binaries, kexts), they
-    // may not have LC_FUNCTION_STARTS / eh_frame sections - we should not make
-    // any assumptions
-    // about them based on that.
+    // binaries, kexts), they may not have LC_FUNCTION_STARTS / eh_frame
+    // sections - we should not make any assumptions about them based on
+    // that.
     if (function_starts_count == 0 && CalculateStrata() == eStrataUser) {
       m_allow_assembly_emulation_unwind_plans = false;
       Log *unwind_or_symbol_log(lldb_private::GetLogIfAnyCategoriesSet(
@@ -2544,8 +2529,8 @@
     ValueToSymbolIndexMap N_FUN_addr_to_sym_idx;
     ValueToSymbolIndexMap N_STSYM_addr_to_sym_idx;
     ConstNameToSymbolIndexMap N_GSYM_name_to_sym_idx;
-    // Any symbols that get merged into another will get an entry
-    // in this map so we know
+    // Any symbols that get merged into another will get an entry in this
+    // map so we know
     NListIndexToSymbolIndexMap m_nlist_idx_to_sym_idx;
     uint32_t nlist_idx = 0;
     Symbol *symbol_ptr = NULL;
@@ -2583,24 +2568,22 @@
 #if defined(__APPLE__) &&                                                      \
     (defined(__arm__) || defined(__arm64__) || defined(__aarch64__))
 
-    // Some recent builds of the dyld_shared_cache (hereafter: DSC) have been
-    // optimized by moving LOCAL
-    // symbols out of the memory mapped portion of the DSC. The symbol
-    // information has all been retained,
-    // but it isn't available in the normal nlist data. However, there *are*
-    // duplicate entries of *some*
-    // LOCAL symbols in the normal nlist data. To handle this situation
-    // correctly, we must first attempt
-    // to parse any DSC unmapped symbol information. If we find any, we set a
-    // flag that tells the normal
-    // nlist parser to ignore all LOCAL symbols.
+    // Some recent builds of the dyld_shared_cache (hereafter: DSC) have
+    // been optimized by moving LOCAL symbols out of the memory mapped
+    // portion of the DSC. The symbol information has all been retained,
+    // but it isn't available in the normal nlist data. However, there
+    // *are* duplicate entries of *some* LOCAL symbols in the normal nlist
+    // data. To handle this situation correctly, we must first attempt to
+    // parse any DSC unmapped symbol information. If we find any, we set a
+    // flag that tells the normal nlist parser to ignore all LOCAL
+    // symbols.
 
     if (m_header.flags & 0x80000000u) {
-      // Before we can start mapping the DSC, we need to make certain the target
-      // process is actually
-      // using the cache we can find.
+      // Before we can start mapping the DSC, we need to make certain the
+      // target process is actually using the cache we can find.
 
-      // Next we need to determine the correct path for the dyld shared cache.
+      // Next we need to determine the correct path for the dyld shared
+      // cache.
 
       ArchSpec header_arch;
       GetArchitecture(header_arch);
@@ -2632,9 +2615,9 @@
         process_shared_cache_uuid = GetProcessSharedCacheUUID(process);
       }
 
-      // First see if we can find an exact match for the inferior process shared
-      // cache UUID in
-      // the development or non-development shared caches on disk.
+      // First see if we can find an exact match for the inferior process
+      // shared cache UUID in the development or non-development shared
+      // caches on disk.
       if (process_shared_cache_uuid.IsValid()) {
         if (dsc_development_filespec.Exists()) {
           UUID dsc_development_uuid = GetSharedCacheUUID(
@@ -2656,8 +2639,8 @@
         }
       }
 
-      // Failing a UUID match, prefer the development dyld_shared cache if both
-      // are present.
+      // Failing a UUID match, prefer the development dyld_shared cache if
+      // both are present.
       if (!dsc_filespec.Exists()) {
         if (dsc_development_filespec.Exists()) {
           dsc_filespec = dsc_development_filespec;
@@ -2698,9 +2681,8 @@
         if (dsc_uuid.IsValid() && process) {
           if (process_shared_cache_uuid.IsValid() &&
               dsc_uuid != process_shared_cache_uuid) {
-            // The on-disk dyld_shared_cache file is not the same as the one in
-            // this
-            // process' memory, don't use it.
+            // The on-disk dyld_shared_cache file is not the same as the
+            // one in this process' memory, don't use it.
             uuid_match = false;
             ModuleSP module_sp(GetModule());
             if (module_sp)
@@ -2714,8 +2696,9 @@
 
         uint32_t mappingOffset = dsc_header_data.GetU32(&offset);
 
-        // If the mappingOffset points to a location inside the header, we've
-        // opened an old dyld shared cache, and should not proceed further.
+        // If the mappingOffset points to a location inside the header,
+        // we've opened an old dyld shared cache, and should not proceed
+        // further.
         if (uuid_match &&
             mappingOffset >= sizeof(struct lldb_copy_dyld_cache_header_v1)) {
 
@@ -2727,13 +2710,11 @@
                                               byte_order, addr_byte_size);
           offset = 0;
 
-          // The File addresses (from the in-memory Mach-O load commands) for
-          // the shared libraries
-          // in the shared library cache need to be adjusted by an offset to
-          // match up with the
-          // dylibOffset identifying field in the
-          // dyld_cache_local_symbol_entry's.  This offset is
-          // recorded in mapping_offset_value.
+          // The File addresses (from the in-memory Mach-O load commands)
+          // for the shared libraries in the shared library cache need to
+          // be adjusted by an offset to match up with the dylibOffset
+          // identifying field in the dyld_cache_local_symbol_entry's.
+          // This offset is recorded in mapping_offset_value.
           const uint64_t mapping_offset_value =
               dsc_mapping_info_data.GetU64(&offset);
 
@@ -2785,8 +2766,8 @@
                 if (header_file_offset == local_symbols_entry.dylibOffset) {
                   unmapped_local_symbols_found = local_symbols_entry.nlistCount;
 
-                  // The normal nlist code cannot correctly size the Symbols
-                  // array, we need to allocate it here.
+                  // The normal nlist code cannot correctly size the
+                  // Symbols array, we need to allocate it here.
                   sym = symtab->Resize(
                       symtab_load_command.nsyms + m_dysymtab.nindirectsyms +
                       unmapped_local_symbols_found - m_dysymtab.nlocalsym);
@@ -2825,9 +2806,9 @@
                           string_table_offset + nlist.n_strx);
 
                       if (symbol_name == NULL) {
-                        // No symbol should be NULL, even the symbols with no
-                        // string values should have an offset zero which points
-                        // to an empty C-string
+                        // No symbol should be NULL, even the symbols with
+                        // no string values should have an offset zero
+                        // which points to an empty C-string
                         Host::SystemLog(
                             Host::eSystemLogError,
                             "error: DSC unmapped local symbol[%u] has invalid "
@@ -2857,19 +2838,20 @@
                         switch (nlist.n_type) {
                         case N_GSYM:
                           // global symbol: name,,NO_SECT,type,0
-                          // Sometimes the N_GSYM value contains the address.
-
-                          // FIXME: In the .o files, we have a GSYM and a debug
-                          // symbol for all the ObjC data.  They
-                          // have the same address, but we want to ensure that
-                          // we always find only the real symbol,
-                          // 'cause we don't currently correctly attribute the
-                          // GSYM one to the ObjCClass/Ivar/MetaClass
-                          // symbol type.  This is a temporary hack to make sure
-                          // the ObjectiveC symbols get treated
-                          // correctly.  To do this right, we should coalesce
-                          // all the GSYM & global symbols that have the
-                          // same address.
+                          // Sometimes the N_GSYM value contains the
+                          // address.
+
+                          // FIXME: In the .o files, we have a GSYM and a
+                          // debug symbol for all the ObjC data.  They
+                          // have the same address, but we want to ensure
+                          // that we always find only the real symbol,
+                          // 'cause we don't currently correctly attribute
+                          // the GSYM one to the ObjCClass/Ivar/MetaClass
+                          // symbol type.  This is a temporary hack to
+                          // make sure the ObjectiveC symbols get treated
+                          // correctly.  To do this right, we should
+                          // coalesce all the GSYM & global symbols that
+                          // have the same address.
 
                           is_gsym = true;
                           sym[sym_idx].SetExternal(true);
@@ -2909,7 +2891,8 @@
                           break;
 
                         case N_FNAME:
-                          // procedure name (f77 kludge): name,,NO_SECT,0,0
+                          // procedure name (f77 kludge):
+                          // name,,NO_SECT,0,0
                           type = eSymbolTypeCompiler;
                           break;
 
@@ -2923,25 +2906,24 @@
                             N_FUN_addr_to_sym_idx.insert(
                                 std::make_pair(nlist.n_value, sym_idx));
                             // We use the current number of symbols in the
-                            // symbol table in lieu of
-                            // using nlist_idx in case we ever start trimming
-                            // entries out
+                            // symbol table in lieu of using nlist_idx in
+                            // case we ever start trimming entries out
                             N_FUN_indexes.push_back(sym_idx);
                           } else {
                             type = eSymbolTypeCompiler;
 
                             if (!N_FUN_indexes.empty()) {
-                              // Copy the size of the function into the original
-                              // STAB entry so we don't have
-                              // to hunt for it later
+                              // Copy the size of the function into the
+                              // original STAB entry so we don't have to
+                              // hunt for it later
                               symtab->SymbolAtIndex(N_FUN_indexes.back())
                                   ->SetByteSize(nlist.n_value);
                               N_FUN_indexes.pop_back();
-                              // We don't really need the end function STAB as
-                              // it contains the size which
-                              // we already placed with the original symbol, so
-                              // don't add it if we want a
-                              // minimal symbol table
+                              // We don't really need the end function
+                              // STAB as it contains the size which we
+                              // already placed with the original symbol,
+                              // so don't add it if we want a minimal
+                              // symbol table
                               add_nlist = false;
                             }
                           }
@@ -2967,21 +2949,20 @@
                           break;
 
                         case N_BNSYM:
-                          // We use the current number of symbols in the symbol
-                          // table in lieu of
-                          // using nlist_idx in case we ever start trimming
-                          // entries out
-                          // Skip these if we want minimal symbol tables
+                          // We use the current number of symbols in the
+                          // symbol table in lieu of using nlist_idx in
+                          // case we ever start trimming entries out Skip
+                          // these if we want minimal symbol tables
                           add_nlist = false;
                           break;
 
                         case N_ENSYM:
-                          // Set the size of the N_BNSYM to the terminating
-                          // index of this N_ENSYM
-                          // so that we can always skip the entire symbol if we
-                          // need to navigate
-                          // more quickly at the source level when parsing STABS
-                          // Skip these if we want minimal symbol tables
+                          // Set the size of the N_BNSYM to the
+                          // terminating index of this N_ENSYM so that we
+                          // can always skip the entire symbol if we need
+                          // to navigate more quickly at the source level
+                          // when parsing STABS Skip these if we want
+                          // minimal symbol tables
                           add_nlist = false;
                           break;
 
@@ -3003,7 +2984,8 @@
                           break;
 
                         case N_SSYM:
-                          // structure elt: name,,NO_SECT,type,struct_offset
+                          // structure elt:
+                          // name,,NO_SECT,type,struct_offset
                           type = eSymbolTypeVariableType;
                           break;
 
@@ -3013,12 +2995,11 @@
                           if (symbol_name == NULL) {
                             add_nlist = false;
                             if (N_SO_index != UINT32_MAX) {
-                              // Set the size of the N_SO to the terminating
-                              // index of this N_SO
-                              // so that we can always skip the entire N_SO if
-                              // we need to navigate
-                              // more quickly at the source level when parsing
-                              // STABS
+                              // Set the size of the N_SO to the
+                              // terminating index of this N_SO so that we
+                              // can always skip the entire N_SO if we
+                              // need to navigate more quickly at the
+                              // source level when parsing STABS
                               symbol_ptr = symtab->SymbolAtIndex(N_SO_index);
                               symbol_ptr->SetByteSize(sym_idx);
                               symbol_ptr->SetSizeIsSibling(true);
@@ -3031,16 +3012,15 @@
                             N_SO_index = UINT32_MAX;
                           } else {
                             // We use the current number of symbols in the
-                            // symbol table in lieu of
-                            // using nlist_idx in case we ever start trimming
-                            // entries out
+                            // symbol table in lieu of using nlist_idx in
+                            // case we ever start trimming entries out
                             const bool N_SO_has_full_path =
                                 symbol_name[0] == '/';
                             if (N_SO_has_full_path) {
                               if ((N_SO_index == sym_idx - 1) &&
                                   ((sym_idx - 1) < num_syms)) {
-                                // We have two consecutive N_SO entries where
-                                // the first contains a directory
+                                // We have two consecutive N_SO entries
+                                // where the first contains a directory
                                 // and the second contains a full path.
                                 sym[sym_idx - 1].GetMangled().SetValue(
                                     ConstString(symbol_name), false);
@@ -3054,9 +3034,9 @@
                               }
                             } else if ((N_SO_index == sym_idx - 1) &&
                                        ((sym_idx - 1) < num_syms)) {
-                              // This is usually the second N_SO entry that
-                              // contains just the filename,
-                              // so here we combine it with the first one if we
+                              // This is usually the second N_SO entry
+                              // that contains just the filename, so here
+                              // we combine it with the first one if we
                               // are minimizing the symbol table
                               const char *so_path =
                                   sym[sym_idx - 1]
@@ -3071,11 +3051,11 @@
                                 if (double_slash_pos != std::string::npos) {
                                   // The linker has been generating bad N_SO
                                   // entries with doubled up paths
-                                  // in the format "%s%s" where the first string
-                                  // in the DW_AT_comp_dir,
-                                  // and the second is the directory for the
-                                  // source file so you end up with
-                                  // a path that looks like "/tmp/src//tmp/src/"
+                                  // in the format "%s%s" where the first
+                                  // string in the DW_AT_comp_dir, and the
+                                  // second is the directory for the
+                                  // source file so you end up with a path
+                                  // that looks like "/tmp/src//tmp/src/"
                                   FileSpec so_dir(so_path, false);
                                   if (!so_dir.Exists()) {
                                     so_dir.SetFile(
@@ -3118,21 +3098,20 @@
                         //----------------------------------------------------------------------
                         case N_BINCL:
                           // include file beginning: name,,NO_SECT,0,sum
-                          // We use the current number of symbols in the symbol
-                          // table in lieu of
-                          // using nlist_idx in case we ever start trimming
-                          // entries out
+                          // We use the current number of symbols in the
+                          // symbol table in lieu of using nlist_idx in
+                          // case we ever start trimming entries out
                           N_INCL_indexes.push_back(sym_idx);
                           type = eSymbolTypeScopeBegin;
                           break;
 
                         case N_EINCL:
                           // include file end: name,,NO_SECT,0,0
-                          // Set the size of the N_BINCL to the terminating
-                          // index of this N_EINCL
-                          // so that we can always skip the entire symbol if we
-                          // need to navigate
-                          // more quickly at the source level when parsing STABS
+                          // Set the size of the N_BINCL to the
+                          // terminating index of this N_EINCL so that we
+                          // can always skip the entire symbol if we need
+                          // to navigate more quickly at the source level
+                          // when parsing STABS
                           if (!N_INCL_indexes.empty()) {
                             symbol_ptr =
                                 symtab->SymbolAtIndex(N_INCL_indexes.back());
@@ -3147,7 +3126,8 @@
                           // #included file name: name,,n_sect,0,address
                           type = eSymbolTypeHeaderFile;
 
-                          // We currently don't use the header files on darwin
+                          // We currently don't use the header files on
+                          // darwin
                           add_nlist = false;
                           break;
 
@@ -3172,7 +3152,8 @@
                           break;
 
                         case N_ENTRY:
-                          // alternate entry: name,,n_sect,linenumber,address
+                          // alternate entry:
+                          // name,,n_sect,linenumber,address
                           symbol_section = section_info.GetSection(
                               nlist.n_sect, nlist.n_value);
                           type = eSymbolTypeLineEntry;
@@ -3182,10 +3163,10 @@
                         // Left and Right Braces
                         //----------------------------------------------------------------------
                         case N_LBRAC:
-                          // left bracket: 0,,NO_SECT,nesting level,address
-                          // We use the current number of symbols in the symbol
-                          // table in lieu of
-                          // using nlist_idx in case we ever start trimming
+                          // left bracket: 0,,NO_SECT,nesting
+                          // level,address We use the current number of
+                          // symbols in the symbol table in lieu of using
+                          // nlist_idx in case we ever start trimming
                           // entries out
                           symbol_section = section_info.GetSection(
                               nlist.n_sect, nlist.n_value);
@@ -3194,12 +3175,12 @@
                           break;
 
                         case N_RBRAC:
-                          // right bracket: 0,,NO_SECT,nesting level,address
-                          // Set the size of the N_LBRAC to the terminating
-                          // index of this N_RBRAC
-                          // so that we can always skip the entire symbol if we
-                          // need to navigate
-                          // more quickly at the source level when parsing STABS
+                          // right bracket: 0,,NO_SECT,nesting
+                          // level,address Set the size of the N_LBRAC to
+                          // the terminating index of this N_RBRAC so that
+                          // we can always skip the entire symbol if we
+                          // need to navigate more quickly at the source
+                          // level when parsing STABS
                           symbol_section = section_info.GetSection(
                               nlist.n_sect, nlist.n_value);
                           if (!N_BRAC_indexes.empty()) {
@@ -3222,10 +3203,9 @@
                         //----------------------------------------------------------------------
                         case N_BCOMM:
                           // begin common: name,,NO_SECT,0,0
-                          // We use the current number of symbols in the symbol
-                          // table in lieu of
-                          // using nlist_idx in case we ever start trimming
-                          // entries out
+                          // We use the current number of symbols in the
+                          // symbol table in lieu of using nlist_idx in
+                          // case we ever start trimming entries out
                           type = eSymbolTypeScopeBegin;
                           N_COMM_indexes.push_back(sym_idx);
                           break;
@@ -3238,11 +3218,11 @@
 
                         case N_ECOMM:
                           // end common: name,,n_sect,0,0
-                          // Set the size of the N_BCOMM to the terminating
-                          // index of this N_ECOMM/N_ECOML
-                          // so that we can always skip the entire symbol if we
-                          // need to navigate
-                          // more quickly at the source level when parsing STABS
+                          // Set the size of the N_BCOMM to the
+                          // terminating index of this N_ECOMM/N_ECOML so
+                          // that we can always skip the entire symbol if
+                          // we need to navigate more quickly at the
+                          // source level when parsing STABS
                           if (!N_COMM_indexes.empty()) {
                             symbol_ptr =
                                 symtab->SymbolAtIndex(N_COMM_indexes.back());
@@ -3531,17 +3511,17 @@
                           if (symbol_byte_size == 0 &&
                               function_starts_count > 0) {
                             addr_t symbol_lookup_file_addr = nlist.n_value;
-                            // Do an exact address match for non-ARM addresses,
-                            // else get the closest since
-                            // the symbol might be a thumb symbol which has an
+                            // Do an exact address match for non-ARM
+                            // addresses, else get the closest since the
+                            // symbol might be a thumb symbol which has an
                             // address with bit zero set
                             FunctionStarts::Entry *func_start_entry =
                                 function_starts.FindEntry(
                                     symbol_lookup_file_addr, !is_arm);
                             if (is_arm && func_start_entry) {
-                              // Verify that the function start address is the
-                              // symbol address (ARM)
-                              // or the symbol address + 1 (thumb)
+                              // Verify that the function start address is
+                              // the symbol address (ARM) or the symbol
+                              // address + 1 (thumb)
                               if (func_start_entry->addr !=
                                       symbol_lookup_file_addr &&
                                   func_start_entry->addr !=
@@ -3572,9 +3552,9 @@
                               if (next_func_start_entry) {
                                 addr_t next_symbol_file_addr =
                                     next_func_start_entry->addr;
-                                // Be sure the clear the Thumb address bit when
-                                // we calculate the size
-                                // from the current and next address
+                                // Be sure the clear the Thumb address bit
+                                // when we calculate the size from the
+                                // current and next address
                                 if (is_arm)
                                   next_symbol_file_addr &=
                                       THUMB_ADDRESS_BIT_MASK;
@@ -3592,12 +3572,10 @@
 
                         if (is_debug == false) {
                           if (type == eSymbolTypeCode) {
-                            // See if we can find a N_FUN entry for any code
-                            // symbols.
-                            // If we do find a match, and the name matches, then
-                            // we
-                            // can merge the two into just the function symbol
-                            // to avoid
+                            // See if we can find a N_FUN entry for any
+                            // code symbols. If we do find a match, and
+                            // the name matches, then we can merge the two
+                            // into just the function symbol to avoid
                             // duplicate entries in the symbol table
                             std::pair<ValueToSymbolIndexMap::const_iterator,
                                       ValueToSymbolIndexMap::const_iterator>
@@ -3645,12 +3623,10 @@
                                      type == eSymbolTypeObjCClass ||
                                      type == eSymbolTypeObjCMetaClass ||
                                      type == eSymbolTypeObjCIVar) {
-                            // See if we can find a N_STSYM entry for any data
-                            // symbols.
-                            // If we do find a match, and the name matches, then
-                            // we
-                            // can merge the two into just the Static symbol to
-                            // avoid
+                            // See if we can find a N_STSYM entry for any
+                            // data symbols. If we do find a match, and
+                            // the name matches, then we can merge the two
+                            // into just the Static symbol to avoid
                             // duplicate entries in the symbol table
                             std::pair<ValueToSymbolIndexMap::const_iterator,
                                       ValueToSymbolIndexMap::const_iterator>
@@ -3672,8 +3648,8 @@
                                       pos->second;
                                   // We just need the flags from the linker
                                   // symbol, so put these flags
-                                  // into the N_STSYM flags to avoid duplicate
-                                  // symbols in the symbol table
+                                  // into the N_STSYM flags to avoid
+                                  // duplicate symbols in the symbol table
                                   sym[pos->second].SetExternal(
                                       sym[sym_idx].IsExternal());
                                   sym[pos->second].SetFlags(nlist.n_type << 16 |
@@ -3693,25 +3669,26 @@
                                                Mangled::ePreferMangled)
                                       .GetCString();
                               if (gsym_name) {
-                                // Combine N_GSYM stab entries with the non stab
-                                // symbol
+                                // Combine N_GSYM stab entries with the
+                                // non stab symbol
                                 ConstNameToSymbolIndexMap::const_iterator pos =
                                     N_GSYM_name_to_sym_idx.find(gsym_name);
                                 if (pos != N_GSYM_name_to_sym_idx.end()) {
                                   const uint32_t GSYM_sym_idx = pos->second;
                                   m_nlist_idx_to_sym_idx[nlist_idx] =
                                       GSYM_sym_idx;
-                                  // Copy the address, because often the N_GSYM
-                                  // address has an invalid address of zero
-                                  // when the global is a common symbol
+                                  // Copy the address, because often the
+                                  // N_GSYM address has an invalid address
+                                  // of zero when the global is a common
+                                  // symbol
                                   sym[GSYM_sym_idx].GetAddressRef().SetSection(
                                       symbol_section);
                                   sym[GSYM_sym_idx].GetAddressRef().SetOffset(
                                       symbol_value);
                                   // We just need the flags from the linker
                                   // symbol, so put these flags
-                                  // into the N_GSYM flags to avoid duplicate
-                                  // symbols in the symbol table
+                                  // into the N_GSYM flags to avoid
+                                  // duplicate symbols in the symbol table
                                   sym[GSYM_sym_idx].SetFlags(
                                       nlist.n_type << 16 | nlist.n_desc);
                                   sym[sym_idx].Clear();
@@ -3810,9 +3787,9 @@
           symbol_name = strtab_data.PeekCStr(nlist.n_strx);
 
           if (symbol_name == NULL) {
-            // No symbol should be NULL, even the symbols with no
-            // string values should have an offset zero which points
-            // to an empty C-string
+            // No symbol should be NULL, even the symbols with no string
+            // values should have an offset zero which points to an empty
+            // C-string
             Host::SystemLog(Host::eSystemLogError,
                             "error: symbol[%u] has invalid string table offset "
                             "0x%x in %s, ignoring symbol\n",
@@ -3848,17 +3825,14 @@
             // global symbol: name,,NO_SECT,type,0
             // Sometimes the N_GSYM value contains the address.
 
-            // FIXME: In the .o files, we have a GSYM and a debug symbol for all
-            // the ObjC data.  They
-            // have the same address, but we want to ensure that we always find
-            // only the real symbol,
-            // 'cause we don't currently correctly attribute the GSYM one to the
-            // ObjCClass/Ivar/MetaClass
-            // symbol type.  This is a temporary hack to make sure the
-            // ObjectiveC symbols get treated
-            // correctly.  To do this right, we should coalesce all the GSYM &
-            // global symbols that have the
-            // same address.
+            // FIXME: In the .o files, we have a GSYM and a debug symbol
+            // for all the ObjC data.  They have the same address, but we
+            // want to ensure that we always find only the real symbol,
+            // 'cause we don't currently correctly attribute the GSYM one
+            // to the ObjCClass/Ivar/MetaClass symbol type.  This is a
+            // temporary hack to make sure the ObjectiveC symbols get
+            // treated correctly.  To do this right, we should coalesce
+            // all the GSYM & global symbols that have the same address.
             is_gsym = true;
             sym[sym_idx].SetExternal(true);
 
@@ -3904,25 +3878,23 @@
 
               N_FUN_addr_to_sym_idx.insert(
                   std::make_pair(nlist.n_value, sym_idx));
-              // We use the current number of symbols in the symbol table in
-              // lieu of
-              // using nlist_idx in case we ever start trimming entries out
+              // We use the current number of symbols in the symbol table
+              // in lieu of using nlist_idx in case we ever start trimming
+              // entries out
               N_FUN_indexes.push_back(sym_idx);
             } else {
               type = eSymbolTypeCompiler;
 
               if (!N_FUN_indexes.empty()) {
-                // Copy the size of the function into the original STAB entry so
-                // we don't have
-                // to hunt for it later
+                // Copy the size of the function into the original STAB
+                // entry so we don't have to hunt for it later
                 symtab->SymbolAtIndex(N_FUN_indexes.back())
                     ->SetByteSize(nlist.n_value);
                 N_FUN_indexes.pop_back();
-                // We don't really need the end function STAB as it contains the
-                // size which
-                // we already placed with the original symbol, so don't add it
-                // if we want a
-                // minimal symbol table
+                // We don't really need the end function STAB as it
+                // contains the size which we already placed with the
+                // original symbol, so don't add it if we want a minimal
+                // symbol table
                 add_nlist = false;
               }
             }
@@ -3948,20 +3920,18 @@
             break;
 
           case N_BNSYM:
-            // We use the current number of symbols in the symbol table in lieu
-            // of
-            // using nlist_idx in case we ever start trimming entries out
-            // Skip these if we want minimal symbol tables
+            // We use the current number of symbols in the symbol table in
+            // lieu of using nlist_idx in case we ever start trimming
+            // entries out Skip these if we want minimal symbol tables
             add_nlist = false;
             break;
 
           case N_ENSYM:
-            // Set the size of the N_BNSYM to the terminating index of this
-            // N_ENSYM
-            // so that we can always skip the entire symbol if we need to
-            // navigate
-            // more quickly at the source level when parsing STABS
-            // Skip these if we want minimal symbol tables
+            // Set the size of the N_BNSYM to the terminating index of
+            // this N_ENSYM so that we can always skip the entire symbol
+            // if we need to navigate more quickly at the source level
+            // when parsing STABS Skip these if we want minimal symbol
+            // tables
             add_nlist = false;
             break;
 
@@ -3993,11 +3963,10 @@
             if (symbol_name == NULL) {
               add_nlist = false;
               if (N_SO_index != UINT32_MAX) {
-                // Set the size of the N_SO to the terminating index of this
-                // N_SO
-                // so that we can always skip the entire N_SO if we need to
-                // navigate
-                // more quickly at the source level when parsing STABS
+                // Set the size of the N_SO to the terminating index of
+                // this N_SO so that we can always skip the entire N_SO if
+                // we need to navigate more quickly at the source level
+                // when parsing STABS
                 symbol_ptr = symtab->SymbolAtIndex(N_SO_index);
                 symbol_ptr->SetByteSize(sym_idx);
                 symbol_ptr->SetSizeIsSibling(true);
@@ -4009,31 +3978,29 @@
               N_FUN_indexes.clear();
               N_SO_index = UINT32_MAX;
             } else {
-              // We use the current number of symbols in the symbol table in
-              // lieu of
-              // using nlist_idx in case we ever start trimming entries out
+              // We use the current number of symbols in the symbol table
+              // in lieu of using nlist_idx in case we ever start trimming
+              // entries out
               const bool N_SO_has_full_path = symbol_name[0] == '/';
               if (N_SO_has_full_path) {
                 if ((N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms)) {
                   // We have two consecutive N_SO entries where the first
-                  // contains a directory
-                  // and the second contains a full path.
+                  // contains a directory and the second contains a full
+                  // path.
                   sym[sym_idx - 1].GetMangled().SetValue(
                       ConstString(symbol_name), false);
                   m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
                   add_nlist = false;
                 } else {
-                  // This is the first entry in a N_SO that contains a directory
-                  // or
-                  // a full path to the source file
+                  // This is the first entry in a N_SO that contains a
+                  // directory or a full path to the source file
                   N_SO_index = sym_idx;
                 }
               } else if ((N_SO_index == sym_idx - 1) &&
                          ((sym_idx - 1) < num_syms)) {
-                // This is usually the second N_SO entry that contains just the
-                // filename,
-                // so here we combine it with the first one if we are minimizing
-                // the symbol table
+                // This is usually the second N_SO entry that contains
+                // just the filename, so here we combine it with the first
+                // one if we are minimizing the symbol table
                 const char *so_path =
                     sym[sym_idx - 1]
                         .GetMangled()
@@ -4043,13 +4010,12 @@
                   std::string full_so_path(so_path);
                   const size_t double_slash_pos = full_so_path.find("//");
                   if (double_slash_pos != std::string::npos) {
-                    // The linker has been generating bad N_SO entries with
-                    // doubled up paths
-                    // in the format "%s%s" where the first string in the
-                    // DW_AT_comp_dir,
-                    // and the second is the directory for the source file so
-                    // you end up with
-                    // a path that looks like "/tmp/src//tmp/src/"
+                    // The linker has been generating bad N_SO entries
+                    // with doubled up paths in the format "%s%s" where
+                    // the first string in the DW_AT_comp_dir, and the
+                    // second is the directory for the source file so you
+                    // end up with a path that looks like
+                    // "/tmp/src//tmp/src/"
                     FileSpec so_dir(so_path, false);
                     if (!so_dir.Exists()) {
                       so_dir.SetFile(&full_so_path[double_slash_pos + 1],
@@ -4089,9 +4055,8 @@
           // INCL scopes
           //----------------------------------------------------------------------
           case N_BINCL:
-            // include file beginning: name,,NO_SECT,0,sum
-            // We use the current number of symbols in the symbol table in lieu
-            // of
+            // include file beginning: name,,NO_SECT,0,sum We use the
+            // current number of symbols in the symbol table in lieu of
             // using nlist_idx in case we ever start trimming entries out
             N_INCL_indexes.push_back(sym_idx);
             type = eSymbolTypeScopeBegin;
@@ -4099,11 +4064,10 @@
 
           case N_EINCL:
             // include file end: name,,NO_SECT,0,0
-            // Set the size of the N_BINCL to the terminating index of this
-            // N_EINCL
-            // so that we can always skip the entire symbol if we need to
-            // navigate
-            // more quickly at the source level when parsing STABS
+            // Set the size of the N_BINCL to the terminating index of
+            // this N_EINCL so that we can always skip the entire symbol
+            // if we need to navigate more quickly at the source level
+            // when parsing STABS
             if (!N_INCL_indexes.empty()) {
               symbol_ptr = symtab->SymbolAtIndex(N_INCL_indexes.back());
               symbol_ptr->SetByteSize(sym_idx + 1);
@@ -4152,9 +4116,8 @@
           // Left and Right Braces
           //----------------------------------------------------------------------
           case N_LBRAC:
-            // left bracket: 0,,NO_SECT,nesting level,address
-            // We use the current number of symbols in the symbol table in lieu
-            // of
+            // left bracket: 0,,NO_SECT,nesting level,address We use the
+            // current number of symbols in the symbol table in lieu of
             // using nlist_idx in case we ever start trimming entries out
             symbol_section =
                 section_info.GetSection(nlist.n_sect, nlist.n_value);
@@ -4163,12 +4126,11 @@
             break;
 
           case N_RBRAC:
-            // right bracket: 0,,NO_SECT,nesting level,address
-            // Set the size of the N_LBRAC to the terminating index of this
-            // N_RBRAC
-            // so that we can always skip the entire symbol if we need to
-            // navigate
-            // more quickly at the source level when parsing STABS
+            // right bracket: 0,,NO_SECT,nesting level,address Set the
+            // size of the N_LBRAC to the terminating index of this
+            // N_RBRAC so that we can always skip the entire symbol if we
+            // need to navigate more quickly at the source level when
+            // parsing STABS
             symbol_section =
                 section_info.GetSection(nlist.n_sect, nlist.n_value);
             if (!N_BRAC_indexes.empty()) {
@@ -4190,9 +4152,9 @@
           //----------------------------------------------------------------------
           case N_BCOMM:
             // begin common: name,,NO_SECT,0,0
-            // We use the current number of symbols in the symbol table in lieu
-            // of
-            // using nlist_idx in case we ever start trimming entries out
+            // We use the current number of symbols in the symbol table in
+            // lieu of using nlist_idx in case we ever start trimming
+            // entries out
             type = eSymbolTypeScopeBegin;
             N_COMM_indexes.push_back(sym_idx);
             break;
@@ -4205,11 +4167,10 @@
 
           case N_ECOMM:
             // end common: name,,n_sect,0,0
-            // Set the size of the N_BCOMM to the terminating index of this
-            // N_ECOMM/N_ECOML
-            // so that we can always skip the entire symbol if we need to
-            // navigate
-            // more quickly at the source level when parsing STABS
+            // Set the size of the N_BCOMM to the terminating index of
+            // this N_ECOMM/N_ECOML so that we can always skip the entire
+            // symbol if we need to navigate more quickly at the source
+            // level when parsing STABS
             if (!N_COMM_indexes.empty()) {
               symbol_ptr = symtab->SymbolAtIndex(N_COMM_indexes.back());
               symbol_ptr->SetByteSize(sym_idx + 1);
@@ -4468,16 +4429,14 @@
             const addr_t section_file_addr = symbol_section->GetFileAddress();
             if (symbol_byte_size == 0 && function_starts_count > 0) {
               addr_t symbol_lookup_file_addr = nlist.n_value;
-              // Do an exact address match for non-ARM addresses, else get the
-              // closest since
-              // the symbol might be a thumb symbol which has an address with
-              // bit zero set
+              // Do an exact address match for non-ARM addresses, else get
+              // the closest since the symbol might be a thumb symbol
+              // which has an address with bit zero set
               FunctionStarts::Entry *func_start_entry =
                   function_starts.FindEntry(symbol_lookup_file_addr, !is_arm);
               if (is_arm && func_start_entry) {
-                // Verify that the function start address is the symbol address
-                // (ARM)
-                // or the symbol address + 1 (thumb)
+                // Verify that the function start address is the symbol
+                // address (ARM) or the symbol address + 1 (thumb)
                 if (func_start_entry->addr != symbol_lookup_file_addr &&
                     func_start_entry->addr != (symbol_lookup_file_addr + 1)) {
                   // Not the right entry, NULL it out...
@@ -4497,9 +4456,8 @@
                     section_file_addr + symbol_section->GetByteSize();
                 if (next_func_start_entry) {
                   addr_t next_symbol_file_addr = next_func_start_entry->addr;
-                  // Be sure the clear the Thumb address bit when we calculate
-                  // the size
-                  // from the current and next address
+                  // Be sure the clear the Thumb address bit when we
+                  // calculate the size from the current and next address
                   if (is_arm)
                     next_symbol_file_addr &= THUMB_ADDRESS_BIT_MASK;
                   symbol_byte_size = std::min<lldb::addr_t>(
@@ -4515,9 +4473,9 @@
 
           if (is_debug == false) {
             if (type == eSymbolTypeCode) {
-              // See if we can find a N_FUN entry for any code symbols.
-              // If we do find a match, and the name matches, then we
-              // can merge the two into just the function symbol to avoid
+              // See if we can find a N_FUN entry for any code symbols. If
+              // we do find a match, and the name matches, then we can
+              // merge the two into just the function symbol to avoid
               // duplicate entries in the symbol table
               std::pair<ValueToSymbolIndexMap::const_iterator,
                         ValueToSymbolIndexMap::const_iterator>
@@ -4534,10 +4492,9 @@
                           lldb::eLanguageTypeUnknown,
                           Mangled::ePreferMangled)) {
                     m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
-                    // We just need the flags from the linker symbol, so put
-                    // these flags
-                    // into the N_FUN flags to avoid duplicate symbols in the
-                    // symbol table
+                    // We just need the flags from the linker symbol, so
+                    // put these flags into the N_FUN flags to avoid
+                    // duplicate symbols in the symbol table
                     sym[pos->second].SetExternal(sym[sym_idx].IsExternal());
                     sym[pos->second].SetFlags(nlist.n_type << 16 |
                                               nlist.n_desc);
@@ -4561,8 +4518,8 @@
                        type == eSymbolTypeObjCMetaClass ||
                        type == eSymbolTypeObjCIVar) {
               // See if we can find a N_STSYM entry for any data symbols.
-              // If we do find a match, and the name matches, then we
-              // can merge the two into just the Static symbol to avoid
+              // If we do find a match, and the name matches, then we can
+              // merge the two into just the Static symbol to avoid
               // duplicate entries in the symbol table
               std::pair<ValueToSymbolIndexMap::const_iterator,
                         ValueToSymbolIndexMap::const_iterator>
@@ -4579,10 +4536,9 @@
                           lldb::eLanguageTypeUnknown,
                           Mangled::ePreferMangled)) {
                     m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
-                    // We just need the flags from the linker symbol, so put
-                    // these flags
-                    // into the N_STSYM flags to avoid duplicate symbols in the
-                    // symbol table
+                    // We just need the flags from the linker symbol, so
+                    // put these flags into the N_STSYM flags to avoid
+                    // duplicate symbols in the symbol table
                     sym[pos->second].SetExternal(sym[sym_idx].IsExternal());
                     sym[pos->second].SetFlags(nlist.n_type << 16 |
                                               nlist.n_desc);
@@ -4606,16 +4562,15 @@
                   if (pos != N_GSYM_name_to_sym_idx.end()) {
                     const uint32_t GSYM_sym_idx = pos->second;
                     m_nlist_idx_to_sym_idx[nlist_idx] = GSYM_sym_idx;
-                    // Copy the address, because often the N_GSYM address has an
-                    // invalid address of zero
-                    // when the global is a common symbol
+                    // Copy the address, because often the N_GSYM address
+                    // has an invalid address of zero when the global is a
+                    // common symbol
                     sym[GSYM_sym_idx].GetAddressRef().SetSection(
                         symbol_section);
                     sym[GSYM_sym_idx].GetAddressRef().SetOffset(symbol_value);
-                    // We just need the flags from the linker symbol, so put
-                    // these flags
-                    // into the N_GSYM flags to avoid duplicate symbols in the
-                    // symbol table
+                    // We just need the flags from the linker symbol, so
+                    // put these flags into the N_GSYM flags to avoid
+                    // duplicate symbols in the symbol table
                     sym[GSYM_sym_idx].SetFlags(nlist.n_type << 16 |
                                                nlist.n_desc);
                     sym[sym_idx].Clear();
@@ -4722,8 +4677,8 @@
       }
     }
 
-    // Trim our symbols down to just what we ended up with after
-    // removing any symbols.
+    // Trim our symbols down to just what we ended up with after removing
+    // any symbols.
     if (sym_idx < num_syms) {
       num_syms = sym_idx;
       sym = symtab->Resize(num_syms);
@@ -4785,13 +4740,11 @@
                   Address so_addr(symbol_stub_addr, section_list);
 
                   if (stub_symbol->GetType() == eSymbolTypeUndefined) {
-                    // Change the external symbol into a trampoline that makes
-                    // sense
-                    // These symbols were N_UNDF N_EXT, and are useless to us,
-                    // so we
-                    // can re-use them so we don't have to make up a synthetic
-                    // symbol
-                    // for no good reason.
+                    // Change the external symbol into a trampoline that
+                    // makes sense These symbols were N_UNDF N_EXT, and
+                    // are useless to us, so we can re-use them so we
+                    // don't have to make up a synthetic symbol for no
+                    // good reason.
                     if (resolver_addresses.find(symbol_stub_addr) ==
                         resolver_addresses.end())
                       stub_symbol->SetType(eSymbolTypeTrampoline);
@@ -4801,7 +4754,8 @@
                     stub_symbol->GetAddressRef() = so_addr;
                     stub_symbol->SetByteSize(symbol_stub_byte_size);
                   } else {
-                    // Make a synthetic symbol to describe the trampoline stub
+                    // Make a synthetic symbol to describe the trampoline
+                    // stub
                     Mangled stub_symbol_mangled_name(stub_symbol->GetMangled());
                     if (sym_idx >= num_syms) {
                       sym = symtab->Resize(++num_syms);
@@ -4836,8 +4790,8 @@
     if (!trie_entries.empty()) {
       for (const auto &e : trie_entries) {
         if (e.entry.import_name) {
-          // Only add indirect symbols from the Trie entries if we
-          // didn't have a N_INDR nlist entry for this already
+          // Only add indirect symbols from the Trie entries if we didn't
+          // have a N_INDR nlist entry for this already
           if (indirect_symbol_names.find(e.entry.name) ==
               indirect_symbol_names.end()) {
             // Make a synthetic symbol to describe re-exported symbol.
@@ -4861,8 +4815,8 @@
     //        StreamFile s(stdout, false);
     //        s.Printf ("Symbol table before CalculateSymbolSizes():\n");
     //        symtab->Dump(&s, NULL, eSortOrderNone);
-    // Set symbol byte sizes correctly since mach-o nlist entries don't have
-    // sizes
+    // Set symbol byte sizes correctly since mach-o nlist entries don't
+    // have sizes
     symtab->CalculateSymbolSizes();
 
     //        s.Printf ("Symbol table after CalculateSymbolSizes():\n");
@@ -4916,8 +4870,9 @@
       const uint8_t *uuid_bytes = data.PeekData(offset, 16);
 
       if (uuid_bytes) {
-        // OpenCL on Mac OS X uses the same UUID for each of its object files.
-        // We pretend these object files have no UUID to prevent crashing.
+        // OpenCL on Mac OS X uses the same UUID for each of its object
+        // files. We pretend these object files have no UUID to prevent
+        // crashing.
 
         const uint8_t opencl_uuid[] = {0x8c, 0x8e, 0xb3, 0x9b, 0x3b, 0xa8,
                                        0x4b, 0x16, 0xb6, 0xa4, 0x27, 0x63,
@@ -4952,15 +4907,15 @@
     if (header.filetype == MH_PRELOAD) {
       if (header.cputype == CPU_TYPE_ARM) {
         // If this is a 32-bit arm binary, and it's a standalone binary,
-        // force the Vendor to Apple so we don't accidentally pick up
-        // the generic armv7 ABI at runtime.  Apple's armv7 ABI always uses
-        // r7 for the frame pointer register; most other armv7 ABIs use a
+        // force the Vendor to Apple so we don't accidentally pick up the
+        // generic armv7 ABI at runtime.  Apple's armv7 ABI always uses r7
+        // for the frame pointer register; most other armv7 ABIs use a
         // combination of r7 and r11.
         triple.setVendor(llvm::Triple::Apple);
       } else {
-        // Set vendor to an unspecified unknown or a "*" so it can match any
-        // vendor
-        // This is required for correct behavior of EFI debugging on x86_64
+        // Set vendor to an unspecified unknown or a "*" so it can match
+        // any vendor This is required for correct behavior of EFI
+        // debugging on x86_64
         triple.setVendor(llvm::Triple::UnknownVendor);
         triple.setVendorName(llvm::StringRef());
       }
@@ -4999,9 +4954,9 @@
       }
 
       if (header.filetype != MH_KEXT_BUNDLE) {
-        // We didn't find a LC_VERSION_MIN load command and this isn't a KEXT
-        // so lets not say our Vendor is Apple, leave it as an unspecified
-        // unknown
+        // We didn't find a LC_VERSION_MIN load command and this isn't a
+        // KEXT so lets not say our Vendor is Apple, leave it as an
+        // unspecified unknown
         triple.setVendor(llvm::Triple::UnknownVendor);
         triple.setVendorName(llvm::StringRef());
       }
@@ -5031,7 +4986,8 @@
     std::vector<std::string> rpath_relative_paths;
     std::vector<std::string> at_exec_relative_paths;
     const bool resolve_path = false; // Don't resolve the dependent file paths
-                                     // since they may not reside on this system
+                                     // since they may not reside on this
+                                     // system
     uint32_t i;
     for (i = 0; i < m_header.ncmds; ++i) {
       const uint32_t cmd_offset = offset;
@@ -5109,10 +5065,10 @@
       }
     }
 
-    // We may have @executable_paths but no RPATHS.  Figure those out here.
-    // Only do this if this object file is the executable.  We have no way to
-    // get back to the actual executable otherwise, so we won't get the right
-    // path.
+    // We may have @executable_paths but no RPATHS.  Figure those out
+    // here. Only do this if this object file is the executable.  We have
+    // no way to get back to the actual executable otherwise, so we won't
+    // get the right path.
     if (!at_exec_relative_paths.empty() && CalculateType() == eTypeExecutable) {
       FileSpec exec_dir = this_file_spec.CopyByRemovingLastPathComponent();
       for (const auto &at_exec_relative_path : at_exec_relative_paths) {
@@ -5128,18 +5084,17 @@
 }
 
 lldb_private::Address ObjectFileMachO::GetEntryPointAddress() {
-  // If the object file is not an executable it can't hold the entry point.
-  // m_entry_point_address
-  // is initialized to an invalid address, so we can just return that.
-  // If m_entry_point_address is valid it means we've found it already, so
-  // return the cached value.
+  // If the object file is not an executable it can't hold the entry
+  // point. m_entry_point_address is initialized to an invalid address, so
+  // we can just return that. If m_entry_point_address is valid it means
+  // we've found it already, so return the cached value.
 
   if (!IsExecutable() || m_entry_point_address.IsValid())
     return m_entry_point_address;
 
-  // Otherwise, look for the UnixThread or Thread command.  The data for the
-  // Thread command is given in
-  // /usr/include/mach-o.h, but it is basically:
+  // Otherwise, look for the UnixThread or Thread command.  The data for
+  // the Thread command is given in /usr/include/mach-o.h, but it is
+  // basically:
   //
   //  uint32_t flavor  - this is the flavor argument you would pass to
   //  thread_get_state
@@ -5148,13 +5103,12 @@
   //  <machine/thread_status.h> corresponding to the flavor.
   //  <repeat this trio>
   //
-  // So we just keep reading the various register flavors till we find the GPR
-  // one, then read the PC out of there.
-  // FIXME: We will need to have a "RegisterContext data provider" class at some
-  // point that can get all the registers
-  // out of data in this form & attach them to a given thread.  That should
-  // underlie the MacOS X User process plugin,
-  // and we'll also need it for the MacOS X Core File process plugin.  When we
+  // So we just keep reading the various register flavors till we find the
+  // GPR one, then read the PC out of there. FIXME: We will need to have a
+  // "RegisterContext data provider" class at some point that can get all
+  // the registers out of data in this form & attach them to a given
+  // thread.  That should underlie the MacOS X User process plugin, and
+  // we'll also need it for the MacOS X Core File process plugin.  When we
   // have that we can also use it here.
   //
   // For now we hard-code the offsets and flavors we need:
@@ -5259,17 +5213,16 @@
     }
 
     if (start_address != LLDB_INVALID_ADDRESS) {
-      // We got the start address from the load commands, so now resolve that
-      // address in the sections
-      // of this ObjectFile:
+      // We got the start address from the load commands, so now resolve
+      // that address in the sections of this ObjectFile:
       if (!m_entry_point_address.ResolveAddressUsingFileSections(
               start_address, GetSectionList())) {
         m_entry_point_address.Clear();
       }
     } else {
-      // We couldn't read the UnixThread load command - maybe it wasn't there.
-      // As a fallback look for the
-      // "start" symbol in the main executable.
+      // We couldn't read the UnixThread load command - maybe it wasn't
+      // there. As a fallback look for the "start" symbol in the main
+      // executable.
 
       ModuleSP module_sp(GetModule());
 
@@ -5334,8 +5287,8 @@
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 
-    // First, look over the load commands for an LC_NOTE load command
-    // with data_owner string "kern ver str" & use that if found.
+    // First, look over the load commands for an LC_NOTE load command with
+    // data_owner string "kern ver str" & use that if found.
     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
     for (uint32_t i = 0; i < m_header.ncmds; ++i) {
       const uint32_t cmd_offset = offset;
@@ -5351,8 +5304,8 @@
           uint64_t fileoff = m_data.GetU64_unchecked (&offset);
           uint64_t size = m_data.GetU64_unchecked (&offset);
 
-          // "kern ver str" has a uint32_t version and then a
-          // nul terminated c-string.
+          // "kern ver str" has a uint32_t version and then a nul
+          // terminated c-string.
           if (strcmp ("kern ver str", data_owner) == 0)
           {
               offset = fileoff;
@@ -5379,8 +5332,8 @@
       offset = cmd_offset + lc.cmdsize;
     }
 
-    // Second, make a pass over the load commands looking for an
-    // obsolete LC_IDENT load command.
+    // Second, make a pass over the load commands looking for an obsolete
+    // LC_IDENT load command.
     offset = MachHeaderSizeFromMagic(m_header.magic);
     for (uint32_t i = 0; i < m_header.ncmds; ++i) {
       const uint32_t cmd_offset = offset;
@@ -5425,7 +5378,8 @@
           uint64_t fileoff = m_data.GetU64_unchecked (&offset);
           uint64_t size = m_data.GetU64_unchecked (&offset);
 
-          // "main bin spec" (main binary specification) data payload is formatted:
+          // "main bin spec" (main binary specification) data payload is
+          // formatted:
           //    uint32_t version       [currently 1]
           //    uint32_t type          [0 == unspecified, 1 == kernel, 2 == user process]
           //    uint64_t address       [ UINT64_MAX if address not specified ]
@@ -5502,12 +5456,12 @@
   switch (m_header.filetype) {
   case MH_OBJECT: // 0x1u
     if (GetAddressByteSize() == 4) {
-      // 32 bit kexts are just object files, but they do have a valid
-      // UUID load command.
+      // 32 bit kexts are just object files, but they do have a valid UUID
+      // load command.
       UUID uuid;
       if (GetUUID(&uuid)) {
-        // this checking for the UUID load command is not enough
-        // we could eventually look for the symbol named
+        // this checking for the UUID load command is not enough we could
+        // eventually look for the symbol named
         // "OSKextGetCurrentIdentifier" as this is required of kexts
         if (m_strata == eStrataInvalid)
           m_strata = eStrataKernel;
@@ -5546,13 +5500,13 @@
   switch (m_header.filetype) {
   case MH_OBJECT: // 0x1u
   {
-    // 32 bit kexts are just object files, but they do have a valid
-    // UUID load command.
+    // 32 bit kexts are just object files, but they do have a valid UUID
+    // load command.
     UUID uuid;
     if (GetUUID(&uuid)) {
-      // this checking for the UUID load command is not enough
-      // we could eventually look for the symbol named
-      // "OSKextGetCurrentIdentifier" as this is required of kexts
+      // this checking for the UUID load command is not enough we could
+      // eventually look for the symbol named "OSKextGetCurrentIdentifier"
+      // as this is required of kexts
       if (m_type == eTypeInvalid)
         m_type = eTypeSharedLibrary;
 
@@ -5841,9 +5795,9 @@
 
 Section *ObjectFileMachO::GetMachHeaderSection() {
   // Find the first address of the mach header which is the first non-zero
-  // file sized section whose file offset is zero. This is the base file address
-  // of the mach-o file which can be subtracted from the vmaddr of the other
-  // segments found in memory and added to the load address
+  // file sized section whose file offset is zero. This is the base file
+  // address of the mach-o file which can be subtracted from the vmaddr of
+  // the other segments found in memory and added to the load address
   ModuleSP module_sp = GetModule();
   if (module_sp) {
     SectionList *section_list = GetSectionList();
@@ -5880,8 +5834,8 @@
           module_sp.get() == section->GetModule().get()) {
         // Ignore __LINKEDIT and __DWARF segments
         if (section->GetName() == GetSegmentNameLINKEDIT()) {
-          // Only map __LINKEDIT if we have an in memory image and this isn't
-          // a kernel binary like a kext or mach_kernel.
+          // Only map __LINKEDIT if we have an in memory image and this
+          // isn't a kernel binary like a kext or mach_kernel.
           const bool is_memory_image = (bool)m_process_wp.lock();
           const Strata strata = GetStrata();
           if (is_memory_image == false || strata == eStrataKernel)
@@ -5907,18 +5861,17 @@
       if (value_is_offset) {
         // "value" is an offset to apply to each top level segment
         for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
-          // Iterate through the object file sections to find all
-          // of the sections that size on disk (to avoid __PAGEZERO)
-          // and load them
+          // Iterate through the object file sections to find all of the
+          // sections that size on disk (to avoid __PAGEZERO) and load
+          // them
           SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
           if (section_sp && section_sp->GetFileSize() > 0 &&
               section_sp->IsThreadSpecific() == false &&
               module_sp.get() == section_sp->GetModule().get()) {
             // Ignore __LINKEDIT and __DWARF segments
             if (section_sp->GetName() == GetSegmentNameLINKEDIT()) {
-              // Only map __LINKEDIT if we have an in memory image and this
-              // isn't
-              // a kernel binary like a kext or mach_kernel.
+              // Only map __LINKEDIT if we have an in memory image and
+              // this isn't a kernel binary like a kext or mach_kernel.
               const bool is_memory_image = (bool)m_process_wp.lock();
               const Strata strata = GetStrata();
               if (is_memory_image == false || strata == eStrataKernel)
@@ -6038,9 +5991,9 @@
                   0};   // uint32_t flags;
               segment_load_commands.push_back(segment);
             } else {
-              // No protections and a size of 1 used to be returned from old
-              // debugservers when we asked about a region that was past the
-              // last memory region and it indicates the end...
+              // No protections and a size of 1 used to be returned from
+              // old debugservers when we asked about a region that was
+              // past the last memory region and it indicates the end...
               if (size == 1)
                 break;
             }
@@ -6068,10 +6021,10 @@
           ThreadList &thread_list = process_sp->GetThreadList();
           const uint32_t num_threads = thread_list.GetSize();
 
-          // Make an array of LC_THREAD data items. Each one contains
-          // the contents of the LC_THREAD load command. The data doesn't
-          // contain the load command + load command size, we will
-          // add the load command and load command size as we emit the data.
+          // Make an array of LC_THREAD data items. Each one contains the
+          // contents of the LC_THREAD load command. The data doesn't
+          // contain the load command + load command size, we will add the
+          // load command and load command size as we emit the data.
           std::vector<StreamString> LC_THREAD_datas(num_threads);
           for (auto &LC_THREAD_data : LC_THREAD_datas) {
             LC_THREAD_data.GetFlags().Set(Stream::eBinary);
@@ -6140,8 +6093,8 @@
             buffer.PutHex32(mach_header.reserved);
           }
 
-          // Skip the mach header and all load commands and align to the next
-          // 0x1000 byte boundary
+          // Skip the mach header and all load commands and align to the
+          // next 0x1000 byte boundary
           addr_t file_offset = buffer.GetSize() + mach_header.sizeofcmds;
           if (file_offset & 0x00000fff) {
             file_offset += 0x00001000ull;
@@ -6201,11 +6154,13 @@
           if (error.Success()) {
             // Read 1 page at a time
             uint8_t bytes[0x1000];
-            // Write the mach header and load commands out to the core file
+            // Write the mach header and load commands out to the core
+            // file
             size_t bytes_written = buffer.GetString().size();
             error = core_file.Write(buffer.GetString().data(), bytes_written);
             if (error.Success()) {
-              // Now write the file data for all memory segments in the process
+              // Now write the file data for all memory segments in the
+              // process
               for (const auto &segment : segment_load_commands) {
                 if (core_file.SeekFromStart(segment.fileoff) == -1) {
                   error.SetErrorStringWithFormat(
Index: source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp
===================================================================
--- source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp
+++ source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp
@@ -158,8 +158,8 @@
 }
 
 lldb::SymbolType ObjectFilePECOFF::MapSymbolType(uint16_t coff_symbol_type) {
-  // TODO:  We need to complete this mapping of COFF symbol types to LLDB ones.
-  // For now, here's a hack to make sure our function have types.
+  // TODO:  We need to complete this mapping of COFF symbol types to LLDB
+  // ones. For now, here's a hack to make sure our function have types.
   const auto complex_type =
       coff_symbol_type >> llvm::COFF::SCT_COMPLEX_TYPE_SHIFT;
   if (complex_type == llvm::COFF::IMAGE_SYM_DTYPE_FUNCTION) {
@@ -236,8 +236,8 @@
       size_t sect_idx = 0;
 
       for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
-        // Iterate through the object file sections to find all
-        // of the sections that have SHF_ALLOC in their flag bits.
+        // Iterate through the object file sections to find all of the
+        // sections that have SHF_ALLOC in their flag bits.
         SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
         if (section_sp && !section_sp->IsThreadSpecific()) {
           if (target.GetSectionLoadList().SetSectionLoadAddress(
@@ -268,8 +268,8 @@
 //----------------------------------------------------------------------
 // NeedsEndianSwap
 //
-// Return true if an endian swap needs to occur when extracting data
-// from this file.
+// Return true if an endian swap needs to occur when extracting data from
+// this file.
 //----------------------------------------------------------------------
 bool ObjectFilePECOFF::NeedsEndianSwap() const {
 #if defined(__LITTLE_ENDIAN__)
@@ -431,7 +431,7 @@
 
 DataExtractor ObjectFilePECOFF::ReadImageData(uint32_t offset, size_t size) {
   if (m_file) {
-    // A bit of a hack, but we intend to write to this buffer, so we can't 
+    // A bit of a hack, but we intend to write to this buffer, so we can't
     // mmap it.
     auto buffer_sp = MapFileData(m_file, size, offset);
     return DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize());
@@ -535,8 +535,8 @@
           DataExtractor strtab_data = ReadImageData(
               m_coff_header.symoff + symbol_data_size, strtab_size);
 
-          // First 4 bytes should be zeroed after strtab_size has been read,
-          // because it is used as offset 0 to encode a NULL string.
+          // First 4 bytes should be zeroed after strtab_size has been
+          // read, because it is used as offset 0 to encode a NULL string.
           uint32_t *strtab_data_start = const_cast<uint32_t *>(
               reinterpret_cast<const uint32_t *>(strtab_data.GetDataStart()));
           strtab_data_start[0] = 0;
@@ -548,9 +548,9 @@
             coff_symbol_t symbol;
             const uint32_t symbol_offset = offset;
             const char *symbol_name_cstr = NULL;
-            // If the first 4 bytes of the symbol string are zero, then they
-            // are followed by a 4-byte string table offset. Else these
-            // 8 bytes contain the symbol name
+            // If the first 4 bytes of the symbol string are zero, then
+            // they are followed by a 4-byte string table offset. Else
+            // these 8 bytes contain the symbol name
             if (symtab_data.GetU32(&offset) == 0) {
               // Long string that doesn't fit into the symbol table name,
               // so now we must read the 4 byte string table offset
@@ -558,8 +558,8 @@
               symbol_name_cstr = strtab_data.PeekCStr(strtab_offset);
               symbol_name.assign(symbol_name_cstr);
             } else {
-              // Short string that fits into the symbol table name which is 8
-              // bytes
+              // Short string that fits into the symbol table name which
+              // is 8 bytes
               offset += sizeof(symbol.name) - 4; // Skip remaining
               symbol_name_cstr = symtab_data.PeekCStr(symbol_offset);
               if (symbol_name_cstr == NULL)
@@ -767,8 +767,8 @@
             module_sp, // Module to which this section belongs
             this,      // Object file to which this section belongs
             idx + 1, // Section ID is the 1 based segment index shifted right by
-                     // 8 bits as not to collide with any of the 256 section IDs
-                     // that are possible
+                     // 8 bits as not to collide with any of the 256
+                     // section IDs that are possible
             const_sect_name, // Name of this section
             section_type,    // This section is a container of other sections.
             m_coff_header_opt.image_base +
Index: source/Plugins/ObjectFile/PECOFF/WindowsMiniDump.cpp
===================================================================
--- source/Plugins/ObjectFile/PECOFF/WindowsMiniDump.cpp
+++ source/Plugins/ObjectFile/PECOFF/WindowsMiniDump.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-// This function is separated out from ObjectFilePECOFF.cpp to name avoid name
-// collisions with WinAPI preprocessor macros.
+// This function is separated out from ObjectFilePECOFF.cpp to name avoid
+// name collisions with WinAPI preprocessor macros.
 
 #include "WindowsMiniDump.h"
 #include "lldb/Utility/FileSpec.h"
Index: source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp
===================================================================
--- source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp
+++ source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp
@@ -311,9 +311,9 @@
     return new_thread_list.GetSize(false) > 0;
   }
   std::vector<Goroutine> goroutines;
-  // The threads that are in "new_thread_list" upon entry are the threads from
-  // the
-  // lldb_private::Process subclass, no memory threads will be in this list.
+  // The threads that are in "new_thread_list" upon entry are the threads
+  // from the lldb_private::Process subclass, no memory threads will be in
+  // this list.
 
   Status err;
   for (uint64_t i = 0; i < allglen; ++i) {
Index: source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp
===================================================================
--- source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp
+++ source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp
@@ -50,8 +50,8 @@
 
 OperatingSystem *OperatingSystemPython::CreateInstance(Process *process,
                                                        bool force) {
-  // Python OperatingSystem plug-ins must be requested by name, so force must be
-  // true
+  // Python OperatingSystem plug-ins must be requested by name, so force
+  // must be true
   FileSpec python_os_plugin_spec(process->GetPythonOSPluginPath());
   if (python_os_plugin_spec && python_os_plugin_spec.Exists()) {
     std::unique_ptr<OperatingSystemPython> os_ap(
@@ -100,8 +100,8 @@
         size_t py_extension_pos = os_plugin_class_name.rfind(".py");
         if (py_extension_pos != std::string::npos)
           os_plugin_class_name.erase(py_extension_pos);
-        // Add ".OperatingSystemPlugIn" to the module name to get a string like
-        // "modulename.OperatingSystemPlugIn"
+        // Add ".OperatingSystemPlugIn" to the module name to get a string
+        // like "modulename.OperatingSystemPlugIn"
         os_plugin_class_name += ".OperatingSystemPlugIn";
         StructuredData::ObjectSP object_sp =
             m_interpreter->OSPlugin_CreatePluginObject(
@@ -157,15 +157,17 @@
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));
 
   // First thing we have to do is to try to get the API lock, and the
-  // interpreter lock. We're going to change the thread content of the process,
-  // and we're going to use python, which requires the API lock to do it. We
-  // need the interpreter lock to make sure thread_info_dict stays alive.
+  // interpreter lock. We're going to change the thread content of the
+  // process, and we're going to use python, which requires the API lock
+  // to do it. We need the interpreter lock to make sure thread_info_dict
+  // stays alive.
   //
-  // If someone already has the API lock, that is ok, we just want to avoid
-  // external code from making new API calls while this call is happening.
+  // If someone already has the API lock, that is ok, we just want to
+  // avoid external code from making new API calls while this call is
+  // happening.
   //
-  // This is a recursive lock so we can grant it to any Python code called on
-  // the stack below us.
+  // This is a recursive lock so we can grant it to any Python code called
+  // on the stack below us.
   Target &target = m_process->GetTarget();
   std::unique_lock<std::recursive_mutex> api_lock(target.GetAPIMutex(),
                                                   std::defer_lock);
@@ -177,9 +179,9 @@
                 "data from python for pid %" PRIu64,
                 m_process->GetID());
 
-  // The threads that are in "new_thread_list" upon entry are the threads from
-  // the lldb_private::Process subclass, no memory threads will be in this
-  // list.
+  // The threads that are in "new_thread_list" upon entry are the threads
+  // from the lldb_private::Process subclass, no memory threads will be in
+  // this list.
   StructuredData::ArraySP threads_list =
       m_interpreter->OSPlugin_ThreadsInfo(m_python_object_sp);
 
@@ -210,10 +212,9 @@
     }
   }
 
-  // Any real core threads that didn't end up backing a memory thread should
-  // still be in the main thread list, and they should be inserted at the
-  // beginning
-  // of the list
+  // Any real core threads that didn't end up backing a memory thread
+  // should still be in the main thread list, and they should be inserted
+  // at the beginning of the list
   uint32_t insert_idx = 0;
   for (uint32_t core_idx = 0; core_idx < num_cores; ++core_idx) {
     if (core_used_map[core_idx] == false) {
@@ -249,9 +250,8 @@
   // See if a thread already exists for "tid"
   thread_sp = old_thread_list.FindThreadByID(tid, false);
   if (thread_sp) {
-    // A thread already does exist for "tid", make sure it was an operating
-    // system
-    // plug-in generated thread.
+    // A thread already does exist for "tid", make sure it was an
+    // operating system plug-in generated thread.
     if (!IsOperatingSystemPluginThread(thread_sp)) {
       // We have thread ID overlap between the protocol threads and the
       // operating system threads, clear the thread so we create an
@@ -271,8 +271,8 @@
     ThreadSP core_thread_sp(
         core_thread_list.GetThreadAtIndex(core_number, false));
     if (core_thread_sp) {
-      // Keep track of which cores were set as the backing thread for memory
-      // threads...
+      // Keep track of which cores were set as the backing thread for
+      // memory threads...
       if (core_number < core_used_map.size())
         core_used_map[core_number] = true;
 
@@ -300,15 +300,17 @@
     return reg_ctx_sp;
 
   // First thing we have to do is to try to get the API lock, and the
-  // interpreter lock. We're going to change the thread content of the process,
-  // and we're going to use python, which requires the API lock to do it. We
-  // need the interpreter lock to make sure thread_info_dict stays alive.
+  // interpreter lock. We're going to change the thread content of the
+  // process, and we're going to use python, which requires the API lock
+  // to do it. We need the interpreter lock to make sure thread_info_dict
+  // stays alive.
   //
-  // If someone already has the API lock, that is ok, we just want to avoid
-  // external code from making new API calls while this call is happening.
+  // If someone already has the API lock, that is ok, we just want to
+  // avoid external code from making new API calls while this call is
+  // happening.
   //
-  // This is a recursive lock so we can grant it to any Python code called on
-  // the stack below us.
+  // This is a recursive lock so we can grant it to any Python code called
+  // on the stack below us.
   Target &target = m_process->GetTarget();
   std::unique_lock<std::recursive_mutex> api_lock(target.GetAPIMutex(),
                                                   std::defer_lock);
@@ -318,8 +320,8 @@
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 
   if (reg_data_addr != LLDB_INVALID_ADDRESS) {
-    // The registers data is in contiguous memory, just create the register
-    // context using the address provided
+    // The registers data is in contiguous memory, just create the
+    // register context using the address provided
     if (log)
       log->Printf("OperatingSystemPython::CreateRegisterContextForThread (tid "
                   "= 0x%" PRIx64 ", 0x%" PRIx64 ", reg_data_addr = 0x%" PRIx64
@@ -328,8 +330,8 @@
     reg_ctx_sp.reset(new RegisterContextMemory(
         *thread, 0, *GetDynamicRegisterInfo(), reg_data_addr));
   } else {
-    // No register data address is provided, query the python plug-in to let
-    // it make up the data as it sees fit
+    // No register data address is provided, query the python plug-in to
+    // let it make up the data as it sees fit
     if (log)
       log->Printf("OperatingSystemPython::CreateRegisterContextForThread (tid "
                   "= 0x%" PRIx64 ", 0x%" PRIx64
@@ -352,8 +354,8 @@
       }
     }
   }
-  // if we still have no register data, fallback on a dummy context to avoid
-  // crashing
+  // if we still have no register data, fallback on a dummy context to
+  // avoid crashing
   if (!reg_ctx_sp) {
     if (log)
       log->Printf("OperatingSystemPython::CreateRegisterContextForThread (tid "
@@ -367,9 +369,9 @@
 
 StopInfoSP
 OperatingSystemPython::CreateThreadStopReason(lldb_private::Thread *thread) {
-  // We should have gotten the thread stop info from the dictionary of data for
-  // the thread in the initial call to get_thread_info(), this should have been
-  // cached so we can return it here
+  // We should have gotten the thread stop info from the dictionary of
+  // data for the thread in the initial call to get_thread_info(), this
+  // should have been cached so we can return it here
   StopInfoSP
       stop_info_sp; //(StopInfo::CreateStopReasonWithSignal (*thread, SIGSTOP));
   return stop_info_sp;
@@ -387,15 +389,16 @@
   if (m_interpreter && m_python_object_sp) {
     // First thing we have to do is to try to get the API lock, and the
     // interpreter lock. We're going to change the thread content of the
-    // process, and we're going to use python, which requires the API lock to
-    // do it. We need the interpreter lock to make sure thread_info_dict stays
-    // alive.
+    // process, and we're going to use python, which requires the API lock
+    // to do it. We need the interpreter lock to make sure
+    // thread_info_dict stays alive.
     //
-    // If someone already has the API lock, that is ok, we just want to avoid
-    // external code from making new API calls while this call is happening.
+    // If someone already has the API lock, that is ok, we just want to
+    // avoid external code from making new API calls while this call is
+    // happening.
     //
-    // This is a recursive lock so we can grant it to any Python code called on
-    // the stack below us.
+    // This is a recursive lock so we can grant it to any Python code
+    // called on the stack below us.
     Target &target = m_process->GetTarget();
     std::unique_lock<std::recursive_mutex> api_lock(target.GetAPIMutex(),
                                                     std::defer_lock);
Index: source/Plugins/Platform/Android/AdbClient.cpp
===================================================================
--- source/Plugins/Platform/Android/AdbClient.cpp
+++ source/Plugins/Platform/Android/AdbClient.cpp
@@ -33,8 +33,8 @@
 #include <fstream>
 #include <sstream>
 
-// On Windows, transitive dependencies pull in <Windows.h>, which defines a
-// macro that clashes with a method name.
+// On Windows, transitive dependencies pull in <Windows.h>, which defines
+// a macro that clashes with a method name.
 #ifdef SendMessage
 #undef SendMessage
 #endif
@@ -374,8 +374,8 @@
   if (error.Fail())
     return error;
 
-  // ADB doesn't propagate return code of shell execution - if
-  // output starts with /system/bin/sh: most likely command failed.
+  // ADB doesn't propagate return code of shell execution - if output
+  // starts with /system/bin/sh: most likely command failed.
   static const char *kShellPrefix = "/system/bin/sh:";
   if (output_buf.size() > strlen(kShellPrefix)) {
     if (!memcmp(&output_buf[0], kShellPrefix, strlen(kShellPrefix)))
Index: source/Plugins/Platform/Android/PlatformAndroid.cpp
===================================================================
--- source/Plugins/Platform/Android/PlatformAndroid.cpp
+++ source/Plugins/Platform/Android/PlatformAndroid.cpp
@@ -83,9 +83,9 @@
       break;
 
 #if defined(__ANDROID__)
-    // Only accept "unknown" for the vendor if the host is android and
-    // it "unknown" wasn't specified (it was just returned because it
-    // was NOT specified_
+    // Only accept "unknown" for the vendor if the host is android and it
+    // "unknown" wasn't specified (it was just returned because it was NOT
+    // specified_
     case llvm::Triple::VendorType::UnknownVendor:
       create = !arch->TripleVendorWasSpecified();
       break;
@@ -100,9 +100,9 @@
         break;
 
 #if defined(__ANDROID__)
-      // Only accept "unknown" for the OS if the host is android and
-      // it "unknown" wasn't specified (it was just returned because it
-      // was NOT specified)
+      // Only accept "unknown" for the OS if the host is android and it
+      // "unknown" wasn't specified (it was just returned because it was
+      // NOT specified)
       case llvm::Triple::OSType::UnknownOS:
         create = !arch->TripleOSWasSpecified();
         break;
@@ -222,8 +222,8 @@
   if (strchr(source_file, '\'') != nullptr)
     return Status("Doesn't support single-quotes in filenames");
 
-  // mode == 0 can signify that adbd cannot access the file
-  // due security constraints - try "cat ..." as a fallback.
+  // mode == 0 can signify that adbd cannot access the file due security
+  // constraints - try "cat ..." as a fallback.
   AdbClient adb(m_device_id);
 
   char cmd[PATH_MAX];
@@ -304,13 +304,15 @@
 
 Status PlatformAndroid::DownloadSymbolFile(const lldb::ModuleSP &module_sp,
                                            const FileSpec &dst_file_spec) {
-  // For oat file we can try to fetch additional debug info from the device
+  // For oat file we can try to fetch additional debug info from the
+  // device
   ConstString extension = module_sp->GetFileSpec().GetFileNameExtension();
   if (extension != ConstString("oat") && extension != ConstString("odex"))
     return Status(
         "Symbol file downloading only supported for oat and odex files");
 
-  // If we have no information about the platform file we can't execute oatdump
+  // If we have no information about the platform file we can't execute
+  // oatdump
   if (!module_sp->GetPlatformFileSpec())
     return Status("No platform file specified");
 
Index: source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp
===================================================================
--- source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp
+++ source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp
@@ -180,9 +180,9 @@
   static const int kAttempsNum = 5;
 
   Status error;
-  // There is a race possibility that somebody will occupy
-  // a port while we're in between FindUnusedPort and ForwardPortWithAdb -
-  // adding the loop to mitigate such problem.
+  // There is a race possibility that somebody will occupy a port while
+  // we're in between FindUnusedPort and ForwardPortWithAdb - adding the
+  // loop to mitigate such problem.
   for (auto i = 0; i < kAttempsNum; ++i) {
     uint16_t local_port = 0;
     error = FindUnusedPort(local_port);
@@ -207,11 +207,10 @@
     llvm::StringRef connect_url, llvm::StringRef plugin_name,
     lldb_private::Debugger &debugger, lldb_private::Target *target,
     lldb_private::Status &error) {
-  // We don't have the pid of the remote gdbserver when it isn't started by us
-  // but we still want
-  // to store the list of port forwards we set up in our port forward map.
-  // Generate a fake pid for
-  // these cases what won't collide with any other valid pid on android.
+  // We don't have the pid of the remote gdbserver when it isn't started
+  // by us but we still want to store the list of port forwards we set up
+  // in our port forward map. Generate a fake pid for these cases what
+  // won't collide with any other valid pid on android.
   static lldb::pid_t s_remote_gdbserver_fake_pid = 0xffffffffffffffffULL;
 
   int remote_port;
Index: source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp
===================================================================
--- source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp
+++ source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp
@@ -60,9 +60,9 @@
       break;
 
 #if defined(__FreeBSD__)
-    // Only accept "unknown" for the OS if the host is BSD and
-    // it "unknown" wasn't specified (it was just returned because it
-    // was NOT specified)
+    // Only accept "unknown" for the OS if the host is BSD and it
+    // "unknown" wasn't specified (it was just returned because it was NOT
+    // specified)
     case llvm::Triple::OSType::UnknownOS:
       create = !arch->TripleOSWasSpecified();
       break;
@@ -143,7 +143,8 @@
         arch = hostArch;
         return arch.IsValid();
       } else if (idx == 1) {
-        // If the default host architecture is 64-bit, look for a 32-bit variant
+        // If the default host architecture is 64-bit, look for a 32-bit
+        // variant
         if (hostArch.IsValid() && hostArch.GetTriple().isArch64Bit()) {
           arch = HostInfo::GetArchitecture(HostInfo::eArchKind32);
           return arch.IsValid();
@@ -186,13 +187,11 @@
     default:
       return false;
     }
-    // Leave the vendor as "llvm::Triple:UnknownVendor" and don't specify the
-    // vendor by
-    // calling triple.SetVendorName("unknown") so that it is a "unspecified
-    // unknown".
-    // This means when someone calls triple.GetVendorName() it will return an
-    // empty string
-    // which indicates that the vendor can be set when two architectures are
+    // Leave the vendor as "llvm::Triple:UnknownVendor" and don't specify
+    // the vendor by calling triple.SetVendorName("unknown") so that it is
+    // a "unspecified unknown". This means when someone calls
+    // triple.GetVendorName() it will return an empty string which
+    // indicates that the vendor can be set when two architectures are
     // merged
 
     // Now set the triple into "arch" and return true
@@ -206,9 +205,9 @@
   Platform::GetStatus(strm);
 
 #ifndef LLDB_DISABLE_POSIX
-  // Display local kernel information only when we are running in host mode.
-  // Otherwise, we would end up printing non-FreeBSD information (when running
-  // on Mac OS for example).
+  // Display local kernel information only when we are running in host
+  // mode. Otherwise, we would end up printing non-FreeBSD information
+  // (when running on Mac OS for example).
   if (IsHost()) {
     struct utsname un;
 
@@ -238,8 +237,8 @@
     }
 
     if (addr_class == eAddressClassCodeAlternateISA) {
-      // TODO: Enable when FreeBSD supports thumb breakpoints.
-      // FreeBSD kernel as of 10.x, does not support thumb breakpoints
+      // TODO: Enable when FreeBSD supports thumb breakpoints. FreeBSD
+      // kernel as of 10.x, does not support thumb breakpoints
       return 0;
     }
 
@@ -287,8 +286,8 @@
     if (target && error.Success()) {
       debugger.GetTargetList().SetSelectedTarget(target);
       // The freebsd always currently uses the GDB remote debugger plug-in
-      // so even when debugging locally we are debugging remotely!
-      // Just like the darwin plugin.
+      // so even when debugging locally we are debugging remotely! Just
+      // like the darwin plugin.
       process_sp = target->CreateProcess(
           attach_info.GetListenerForProcess(debugger), "gdb-remote", NULL);
 
Index: source/Plugins/Platform/Linux/PlatformLinux.cpp
===================================================================
--- source/Plugins/Platform/Linux/PlatformLinux.cpp
+++ source/Plugins/Platform/Linux/PlatformLinux.cpp
@@ -30,8 +30,8 @@
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
-// Define these constants from Linux mman.h for use when targeting
-// remote linux systems even when host has different values.
+// Define these constants from Linux mman.h for use when targeting remote
+// linux systems even when host has different values.
 #define MAP_PRIVATE 2
 #define MAP_ANON 0x20
 
@@ -58,9 +58,9 @@
       break;
 
 #if defined(__linux__)
-    // Only accept "unknown" for the OS if the host is linux and
-    // it "unknown" wasn't specified (it was just returned because it
-    // was NOT specified)
+    // Only accept "unknown" for the OS if the host is linux and it
+    // "unknown" wasn't specified (it was just returned because it was NOT
+    // specified)
     case llvm::Triple::OSType::UnknownOS:
       create = !arch->TripleOSWasSpecified();
       break;
@@ -142,7 +142,8 @@
         arch = hostArch;
         return arch.IsValid();
       } else if (idx == 1) {
-        // If the default host architecture is 64-bit, look for a 32-bit variant
+        // If the default host architecture is 64-bit, look for a 32-bit
+        // variant
         if (hostArch.IsValid() && hostArch.GetTriple().isArch64Bit()) {
           arch = HostInfo::GetArchitecture(HostInfo::eArchKind32);
           return arch.IsValid();
@@ -191,13 +192,11 @@
     default:
       return false;
     }
-    // Leave the vendor as "llvm::Triple:UnknownVendor" and don't specify the
-    // vendor by
-    // calling triple.SetVendorName("unknown") so that it is a "unspecified
-    // unknown".
-    // This means when someone calls triple.GetVendorName() it will return an
-    // empty string
-    // which indicates that the vendor can be set when two architectures are
+    // Leave the vendor as "llvm::Triple:UnknownVendor" and don't specify
+    // the vendor by calling triple.SetVendorName("unknown") so that it is
+    // a "unspecified unknown". This means when someone calls
+    // triple.GetVendorName() it will return an empty string which
+    // indicates that the vendor can be set when two architectures are
     // merged
 
     // Now set the triple into "arch" and return true
@@ -211,9 +210,9 @@
   Platform::GetStatus(strm);
 
 #ifndef LLDB_DISABLE_POSIX
-  // Display local kernel information only when we are running in host mode.
-  // Otherwise, we would end up printing non-Linux information (when running
-  // on Mac OS for example).
+  // Display local kernel information only when we are running in host
+  // mode. Otherwise, we would end up printing non-Linux information (when
+  // running on Mac OS for example).
   if (IsHost()) {
     struct utsname un;
 
@@ -271,9 +270,9 @@
   }
 }
 
-// For local debugging, Linux will override the debug logic to use llgs-launch
-// rather than lldb-launch, llgs-attach.  This differs from current lldb-launch,
-// debugserver-attach approach on MacOSX.
+// For local debugging, Linux will override the debug logic to use llgs-
+// launch rather than lldb-launch, llgs-attach.  This differs from current
+// lldb-launch, debugserver-attach approach on MacOSX.
 lldb::ProcessSP
 PlatformLinux::DebugProcess(ProcessLaunchInfo &launch_info, Debugger &debugger,
                             Target *target, // Can be NULL, if NULL create a new
@@ -287,8 +286,8 @@
     return PlatformPOSIX::DebugProcess(launch_info, debugger, target, error);
 
   //
-  // For local debugging, we'll insist on having ProcessGDBRemote create the
-  // process.
+  // For local debugging, we'll insist on having ProcessGDBRemote create
+  // the process.
   //
 
   ProcessSP process_sp;
@@ -296,9 +295,9 @@
   // Make sure we stop at the entry point
   launch_info.GetFlags().Set(eLaunchFlagDebug);
 
-  // We always launch the process we are going to debug in a separate process
-  // group, since then we can handle ^C interrupts ourselves w/o having to worry
-  // about the target getting them as well.
+  // We always launch the process we are going to debug in a separate
+  // process group, since then we can handle ^C interrupts ourselves w/o
+  // having to worry about the target getting them as well.
   launch_info.SetLaunchInSeparateProcessGroup(true);
 
   // Ensure we have a target.
@@ -369,8 +368,8 @@
       LLDB_LOG(log, "pid {0} state {0}", process_sp->GetID(), state);
     }
 
-    // Hook up process PTY if we have one (which we should for local debugging
-    // with llgs).
+    // Hook up process PTY if we have one (which we should for local
+    // debugging with llgs).
     int pty_fd = launch_info.GetPTY().ReleaseMasterFileDescriptor();
     if (pty_fd != PseudoTerminal::invalid_fd) {
       process_sp->SetSTDIOFileDescriptor(pty_fd);
@@ -379,8 +378,8 @@
       LLDB_LOG(log, "not using process STDIO pty");
   } else {
     LLDB_LOG(log, "process launch failed: {0}", error);
-    // FIXME figure out appropriate cleanup here.  Do we delete the target? Do
-    // we delete the process?  Does our caller do that?
+    // FIXME figure out appropriate cleanup here.  Do we delete the
+    // target? Do we delete the process?  Does our caller do that?
   }
 
   return process_sp;
Index: source/Plugins/Platform/MacOSX/PlatformAppleSimulator.cpp
===================================================================
--- source/Plugins/Platform/MacOSX/PlatformAppleSimulator.cpp
+++ source/Plugins/Platform/MacOSX/PlatformAppleSimulator.cpp
@@ -182,9 +182,9 @@
   ProcessSP process_sp;
   // Make sure we stop at the entry point
   launch_info.GetFlags().Set(eLaunchFlagDebug);
-  // We always launch the process we are going to debug in a separate process
-  // group, since then we can handle ^C interrupts ourselves w/o having to worry
-  // about the target getting them as well.
+  // We always launch the process we are going to debug in a separate
+  // process group, since then we can handle ^C interrupts ourselves w/o
+  // having to worry about the target getting them as well.
   launch_info.SetLaunchInSeparateProcessGroup(true);
 
   error = LaunchProcess(launch_info);
@@ -195,10 +195,10 @@
       if (process_sp) {
         launch_info.SetHijackListener(attach_info.GetHijackListener());
 
-        // Since we attached to the process, it will think it needs to detach
-        // if the process object just goes away without an explicit call to
-        // Process::Kill() or Process::Detach(), so let it know to kill the
-        // process if this happens.
+        // Since we attached to the process, it will think it needs to
+        // detach if the process object just goes away without an explicit
+        // call to Process::Kill() or Process::Detach(), so let it know to
+        // kill the process if this happens.
         process_sp->SetShouldDetach(false);
 
         // If we didn't have any file actions, the pseudo terminal might
Index: source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.cpp
===================================================================
--- source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.cpp
+++ source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.cpp
@@ -90,9 +90,9 @@
         break;
 
 #if defined(__APPLE__)
-      // Only accept "unknown" for the vendor if the host is Apple and
-      // it "unknown" wasn't specified (it was just returned because it
-      // was NOT specified)
+      // Only accept "unknown" for the vendor if the host is Apple and it
+      // "unknown" wasn't specified (it was just returned because it was
+      // NOT specified)
       case llvm::Triple::UnknownArch:
         create = !arch->TripleVendorWasSpecified();
         break;
@@ -107,9 +107,9 @@
           break;
 
 #if defined(__APPLE__)
-        // Only accept "unknown" for the OS if the host is Apple and
-        // it "unknown" wasn't specified (it was just returned because it
-        // was NOT specified)
+        // Only accept "unknown" for the OS if the host is Apple and it
+        // "unknown" wasn't specified (it was just returned because it was
+        // NOT specified)
         case llvm::Triple::UnknownOS:
           create = !arch->TripleOSWasSpecified();
           break;
@@ -179,15 +179,14 @@
 
   ModuleSpec resolved_module_spec(module_spec);
 
-  // If we have "ls" as the exe_file, resolve the executable loation based on
-  // the current path variables
-  // TODO: resolve bare executables in the Platform SDK
+  // If we have "ls" as the exe_file, resolve the executable loation based
+  // on the current path variables TODO: resolve bare executables in the
+  // Platform SDK
   //    if (!resolved_exe_file.Exists())
   //        resolved_exe_file.ResolveExecutableLocation ();
 
-  // Resolve any executable within a bundle on MacOSX
-  // TODO: verify that this handles shallow bundles, if not then implement one
-  // ourselves
+  // Resolve any executable within a bundle on MacOSX TODO: verify that
+  // this handles shallow bundles, if not then implement one ourselves
   Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
 
   if (resolved_module_spec.GetFileSpec().Exists()) {
@@ -201,7 +200,8 @@
     }
     // No valid architecture was specified or the exact ARM slice wasn't
     // found so ask the platform for the architectures that we should be
-    // using (in the correct order) and see if we can find a match that way
+    // using (in the correct order) and see if we can find a match that
+    // way
     StreamString arch_names;
     ArchSpec platform_arch;
     for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
@@ -288,13 +288,14 @@
         return m_sdk_directory.c_str();
       }
     }
-    // Assign a single NULL character so we know we tried to find the device
-    // support directory and we don't keep trying to find it over and over.
+    // Assign a single NULL character so we know we tried to find the
+    // device support directory and we don't keep trying to find it over
+    // and over.
     m_sdk_directory.assign(1, '\0');
   }
 
-  // We should have put a single NULL character into m_sdk_directory
-  // or it should have a valid path if the code gets here
+  // We should have put a single NULL character into m_sdk_directory or it
+  // should have a valid path if the code gets here
   assert(m_sdk_directory.empty() == false);
   if (m_sdk_directory[0])
     return m_sdk_directory.c_str();
@@ -337,10 +338,9 @@
     const ModuleSpec &module_spec, lldb_private::Process *process,
     ModuleSP &module_sp, const FileSpecList *module_search_paths_ptr,
     ModuleSP *old_module_sp_ptr, bool *did_create_ptr) {
-  // For AppleTV, the SDK files are all cached locally on the host
-  // system. So first we ask for the file in the cached SDK,
-  // then we attempt to get a shared module for the right architecture
-  // with the right UUID.
+  // For AppleTV, the SDK files are all cached locally on the host system.
+  // So first we ask for the file in the cached SDK, then we attempt to
+  // get a shared module for the right architecture with the right UUID.
   Status error;
   ModuleSpec platform_module_spec(module_spec);
   const FileSpec &platform_file = module_spec.GetFileSpec();
Index: source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.cpp
===================================================================
--- source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.cpp
+++ source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.cpp
@@ -89,9 +89,9 @@
         break;
 
 #if defined(__APPLE__)
-      // Only accept "unknown" for the vendor if the host is Apple and
-      // it "unknown" wasn't specified (it was just returned because it
-      // was NOT specified)
+      // Only accept "unknown" for the vendor if the host is Apple and it
+      // "unknown" wasn't specified (it was just returned because it was
+      // NOT specified)
       case llvm::Triple::UnknownArch:
         create = !arch->TripleVendorWasSpecified();
         break;
@@ -106,9 +106,9 @@
           break;
 
 #if defined(__APPLE__)
-        // Only accept "unknown" for the OS if the host is Apple and
-        // it "unknown" wasn't specified (it was just returned because it
-        // was NOT specified)
+        // Only accept "unknown" for the OS if the host is Apple and it
+        // "unknown" wasn't specified (it was just returned because it was
+        // NOT specified)
         case llvm::Triple::UnknownOS:
           create = !arch->TripleOSWasSpecified();
           break;
@@ -179,15 +179,14 @@
 
   ModuleSpec resolved_module_spec(module_spec);
 
-  // If we have "ls" as the exe_file, resolve the executable loation based on
-  // the current path variables
-  // TODO: resolve bare executables in the Platform SDK
+  // If we have "ls" as the exe_file, resolve the executable loation based
+  // on the current path variables TODO: resolve bare executables in the
+  // Platform SDK
   //    if (!resolved_exe_file.Exists())
   //        resolved_exe_file.ResolveExecutableLocation ();
 
-  // Resolve any executable within a bundle on MacOSX
-  // TODO: verify that this handles shallow bundles, if not then implement one
-  // ourselves
+  // Resolve any executable within a bundle on MacOSX TODO: verify that
+  // this handles shallow bundles, if not then implement one ourselves
   Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
 
   if (resolved_module_spec.GetFileSpec().Exists()) {
@@ -201,7 +200,8 @@
     }
     // No valid architecture was specified or the exact ARM slice wasn't
     // found so ask the platform for the architectures that we should be
-    // using (in the correct order) and see if we can find a match that way
+    // using (in the correct order) and see if we can find a match that
+    // way
     StreamString arch_names;
     ArchSpec platform_arch;
     for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
@@ -288,13 +288,14 @@
         return m_sdk_directory.c_str();
       }
     }
-    // Assign a single NULL character so we know we tried to find the device
-    // support directory and we don't keep trying to find it over and over.
+    // Assign a single NULL character so we know we tried to find the
+    // device support directory and we don't keep trying to find it over
+    // and over.
     m_sdk_directory.assign(1, '\0');
   }
 
-  // We should have put a single NULL character into m_sdk_directory
-  // or it should have a valid path if the code gets here
+  // We should have put a single NULL character into m_sdk_directory or it
+  // should have a valid path if the code gets here
   assert(m_sdk_directory.empty() == false);
   if (m_sdk_directory[0])
     return m_sdk_directory.c_str();
@@ -338,9 +339,9 @@
     ModuleSP &module_sp, const FileSpecList *module_search_paths_ptr,
     ModuleSP *old_module_sp_ptr, bool *did_create_ptr) {
   // For AppleWatch, the SDK files are all cached locally on the host
-  // system. So first we ask for the file in the cached SDK,
-  // then we attempt to get a shared module for the right architecture
-  // with the right UUID.
+  // system. So first we ask for the file in the cached SDK, then we
+  // attempt to get a shared module for the right architecture with the
+  // right UUID.
   Status error;
   ModuleSpec platform_module_spec(module_spec);
   const FileSpec &platform_file = module_spec.GetFileSpec();
Index: source/Plugins/Platform/MacOSX/PlatformDarwin.cpp
===================================================================
--- source/Plugins/Platform/MacOSX/PlatformDarwin.cpp
+++ source/Plugins/Platform/MacOSX/PlatformDarwin.cpp
@@ -71,12 +71,11 @@
   if (target &&
       target->GetDebugger().GetScriptLanguage() == eScriptLanguagePython) {
     // NB some extensions might be meaningful and should not be stripped -
-    // "this.binary.file"
-    // should not lose ".file" but GetFileNameStrippingExtension() will do
-    // precisely that.
-    // Ideally, we should have a per-platform list of extensions (".exe",
-    // ".app", ".dSYM", ".framework")
-    // which should be stripped while leaving "this.binary.file" as-is.
+    // "this.binary.file" should not lose ".file" but
+    // GetFileNameStrippingExtension() will do precisely that. Ideally, we
+    // should have a per-platform list of extensions (".exe", ".app",
+    // ".dSYM", ".framework") which should be stripped while leaving
+    // "this.binary.file" as-is.
     ScriptInterpreter *script_interpreter =
         target->GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
 
@@ -98,17 +97,13 @@
 
                 bool was_keyword = false;
 
-                // FIXME: for Python, we cannot allow certain characters in
-                // module
-                // filenames we import. Theoretically, different scripting
-                // languages may
-                // have different sets of forbidden tokens in filenames, and
-                // that should
-                // be dealt with by each ScriptInterpreter. For now, we just
-                // replace dots
-                // with underscores, but if we ever support anything other than
-                // Python
-                // we will need to rework this
+                // FIXME: for Python, we cannot allow certain characters
+                // in module filenames we import. Theoretically, different
+                // scripting languages may have different sets of
+                // forbidden tokens in filenames, and that should be dealt
+                // with by each ScriptInterpreter. For now, we just
+                // replace dots with underscores, but if we ever support
+                // anything other than Python we will need to rework this
                 std::replace(module_basename.begin(), module_basename.end(),
                              '.', '_');
                 std::replace(module_basename.begin(), module_basename.end(),
@@ -125,9 +120,9 @@
                 StreamString path_string;
                 StreamString original_path_string;
                 // for OSX we are going to be in
-                // .dSYM/Contents/Resources/DWARF/<basename>
-                // let us go to .dSYM/Contents/Resources/Python/<basename>.py
-                // and see if the file exists
+                // .dSYM/Contents/Resources/DWARF/<basename> let us go to
+                // .dSYM/Contents/Resources/Python/<basename>.py and see
+                // if the file exists
                 path_string.Printf("%s/../Python/%s.py",
                                    symfile_spec.GetDirectory().GetCString(),
                                    module_basename.c_str());
@@ -139,10 +134,9 @@
                 FileSpec orig_script_fspec(original_path_string.GetString(),
                                            true);
 
-                // if we did some replacements of reserved characters, and a
-                // file with the untampered name
-                // exists, then warn the user that the file as-is shall not be
-                // loaded
+                // if we did some replacements of reserved characters, and
+                // a file with the untampered name exists, then warn the
+                // user that the file as-is shall not be loaded
                 if (feedback_stream) {
                   if (module_basename != original_module_basename &&
                       orig_script_fspec.Exists()) {
@@ -178,8 +172,8 @@
                   break;
                 }
 
-                // If we didn't find the python file, then keep
-                // stripping the extensions and try again
+                // If we didn't find the python file, then keep stripping
+                // the extensions and try again
                 ConstString filename_no_extension(
                     module_spec.GetFileNameStrippingExtension());
                 if (module_spec.GetFilename() == filename_no_extension)
@@ -269,9 +263,9 @@
       cache_path.append(module_path);
       FileSpec module_cache_spec(cache_path, false);
 
-      // if rsync is supported, always bring in the file - rsync will be very
-      // efficient
-      // when files are the same on the local and remote end of the connection
+      // if rsync is supported, always bring in the file - rsync will be
+      // very efficient when files are the same on the local and remote
+      // end of the connection
       if (this->GetSupportsRSync()) {
         err = BringInRemoteFile(this, module_spec, module_cache_spec);
         if (err.Fail())
@@ -295,9 +289,9 @@
       if (module_cache_spec.Exists()) {
         // get the local and remote MD5 and compare
         if (m_remote_platform_sp) {
-          // when going over the *slow* GDB remote transfer mechanism we first
-          // check the hashes of the files - and only do the actual transfer if
-          // they differ
+          // when going over the *slow* GDB remote transfer mechanism we
+          // first check the hashes of the files - and only do the actual
+          // transfer if they differ
           uint64_t high_local, high_remote, low_local, low_remote;
           auto MD5 = llvm::sys::fs::md5_contents(module_cache_spec.GetPath());
           if (!MD5)
@@ -370,8 +364,8 @@
   module_sp.reset();
 
   if (IsRemote()) {
-    // If we have a remote platform always, let it try and locate
-    // the shared module first.
+    // If we have a remote platform always, let it try and locate the
+    // shared module first.
     if (m_remote_platform_sp) {
       error = m_remote_platform_sp->GetSharedModule(
           module_spec, process, module_sp, module_search_paths_ptr,
@@ -453,8 +447,8 @@
   switch (machine) {
   case llvm::Triple::aarch64: {
     // TODO: fix this with actual darwin breakpoint opcode for arm64.
-    // right now debugging uses the Z packets with GDB remote so this
-    // is not needed, but the size needs to be correct...
+    // right now debugging uses the Z packets with GDB remote so this is
+    // not needed, but the size needs to be correct...
     static const uint8_t g_arm64_breakpoint_opcode[] = {0xFE, 0xDE, 0xFF, 0xE7};
     trap_opcode = g_arm64_breakpoint_opcode;
     trap_opcode_size = sizeof(g_arm64_breakpoint_opcode);
@@ -547,9 +541,9 @@
       ArchSpec platform_arch64(
           HostInfo::GetArchitecture(HostInfo::eArchKind64));
       if (platform_arch.IsExactMatch(platform_arch64)) {
-        // This macosx platform supports both 32 and 64 bit. Since we already
-        // returned the 64 bit arch for idx == 0, return the 32 bit arch
-        // for idx == 1
+        // This macosx platform supports both 32 and 64 bit. Since we
+        // already returned the 64 bit arch for idx == 0, return the 32
+        // bit arch for idx == 1
         arch = HostInfo::GetArchitecture(HostInfo::eArchKind32);
         return arch.IsValid();
       }
@@ -558,15 +552,16 @@
   return false;
 }
 
-// The architecture selection rules for arm processors
-// These cpu subtypes have distinct names (e.g. armv7f) but armv7 binaries run
-// fine on an armv7f processor.
+// The architecture selection rules for arm processors These cpu subtypes
+// have distinct names (e.g. armv7f) but armv7 binaries run fine on an
+// armv7f processor.
 
 bool PlatformDarwin::ARMGetSupportedArchitectureAtIndex(uint32_t idx,
                                                         ArchSpec &arch) {
   ArchSpec system_arch(GetSystemArchitecture());
 
-// When lldb is running on a watch or tv, set the arch OS name appropriately.
+// When lldb is running on a watch or tv, set the arch OS name
+// appropriately.
 #if defined(TARGET_OS_TV) && TARGET_OS_TV == 1
 #define OSNAME "tvos"
 #elif defined(TARGET_OS_WATCH) && TARGET_OS_WATCH == 1
@@ -1145,7 +1140,8 @@
     if (HostInfo::GetLLDBPath(ePathTypeLLDBShlibDir, temp_file_spec)) {
       if (temp_file_spec.GetPath(developer_dir_path,
                                  sizeof(developer_dir_path))) {
-        // e.g. /Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework
+        // e.g.
+        // /Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework
         char *shared_frameworks =
             strstr(developer_dir_path, "/SharedFrameworks/LLDB.framework");
         if (shared_frameworks) {
@@ -1153,7 +1149,8 @@
           strncat (developer_dir_path, "/Developer", sizeof (developer_dir_path) - 1); // add /Developer on
           developer_dir_path_valid = true;
         } else {
-          // e.g. /Applications/Xcode.app/Contents/Developer/Toolchains/iOS11.2.xctoolchain/System/Library/PrivateFrameworks/LLDB.framework
+          // e.g.
+          // /Applications/Xcode.app/Contents/Developer/Toolchains/iOS11.2.xctoolchain/System/Library/PrivateFrameworks/LLDB.framework
           char *developer_toolchains =
             strstr(developer_dir_path, "/Contents/Developer/Toolchains/");
           if (developer_toolchains) {
@@ -1176,8 +1173,8 @@
           DataBufferLLVM::CreateFromPath(temp_file_spec.GetPath());
       if (dir_buffer && dir_buffer->GetByteSize() > 0) {
         llvm::StringRef path_ref(dir_buffer->GetChars());
-        // Trim tailing newlines and make sure there is enough room for a null
-        // terminator.
+        // Trim tailing newlines and make sure there is enough room for a
+        // null terminator.
         path_ref =
             path_ref.rtrim("\r\n").take_front(sizeof(developer_dir_path) - 1);
         ::memcpy(developer_dir_path, path_ref.data(), path_ref.size());
@@ -1225,8 +1222,9 @@
         return m_developer_directory.c_str();
       }
     }
-    // Assign a single NULL character so we know we tried to find the device
-    // support directory and we don't keep trying to find it over and over.
+    // Assign a single NULL character so we know we tried to find the
+    // device support directory and we don't keep trying to find it over
+    // and over.
     m_developer_directory.assign(1, '\0');
   }
 
@@ -1279,9 +1277,9 @@
     shell_name++;
 
   if (strcmp(shell_name, "sh") == 0) {
-    // /bin/sh re-exec's itself as /bin/bash requiring another resume.
-    // But it only does this if the COMMAND_MODE environment variable
-    // is set to "legacy".
+    // /bin/sh re-exec's itself as /bin/bash requiring another resume. But
+    // it only does this if the COMMAND_MODE environment variable is set
+    // to "legacy".
     if (launch_info.GetEnvironment().lookup("COMMAND_MODE") == "legacy")
       return 2;
     return 1;
@@ -1331,11 +1329,10 @@
 
     FileSpec fspec;
 
-    // First get the program file spec. If lldb.so or LLDB.framework is running
-    // in a program and that program is Xcode, the path returned with be the
-    // path
-    // to Xcode.app/Contents/MacOS/Xcode, so this will be the correct Xcode to
-    // use.
+    // First get the program file spec. If lldb.so or LLDB.framework is
+    // running in a program and that program is Xcode, the path returned
+    // with be the path to Xcode.app/Contents/MacOS/Xcode, so this will be
+    // the correct Xcode to use.
     fspec = HostInfo::GetProgramFileSpec();
 
     if (fspec) {
@@ -1522,8 +1519,8 @@
 
     if (HostInfo::GetOSVersion(major, minor, micro)) {
       if (SDKSupportsModules(SDKType::MacOSX, major, minor, micro)) {
-        // We slightly prefer the exact SDK for this machine.  See if it is
-        // there.
+        // We slightly prefer the exact SDK for this machine.  See if it
+        // is there.
 
         FileSpec native_sdk_spec = sdks_spec;
         StreamString native_sdk_name;
@@ -1595,8 +1592,8 @@
   if (use_current_os_version)
     versions_valid = GetOSVersion(versions[0], versions[1], versions[2]);
   else if (target) {
-    // Our OS doesn't match our executable so we need to get the min OS version
-    // from the object file
+    // Our OS doesn't match our executable so we need to get the min OS
+    // version from the object file
     ModuleSP exe_module_sp = target->GetExecutableModule();
     if (exe_module_sp) {
       ObjectFile *object_file = exe_module_sp->GetObjectFile();
@@ -1679,9 +1676,8 @@
       }
     }
     // For simulator platforms, do NOT call back through
-    // Platform::GetOSVersion()
-    // as it might call Process::GetHostOSVersion() which we don't want as it
-    // will be
+    // Platform::GetOSVersion() as it might call
+    // Process::GetHostOSVersion() which we don't want as it will be
     // incorrect
     return false;
   }
@@ -1690,9 +1686,8 @@
 }
 
 lldb_private::FileSpec PlatformDarwin::LocateExecutable(const char *basename) {
-  // A collection of SBFileSpec whose SBFileSpec.m_directory members are filled
-  // in with
-  // any executable directories that should be searched.
+  // A collection of SBFileSpec whose SBFileSpec.m_directory members are
+  // filled in with any executable directories that should be searched.
   static std::vector<FileSpec> g_executable_dirs;
 
   // Find the global list of directories that we will search for
@@ -1700,7 +1695,8 @@
   static llvm::once_flag g_once_flag;
   llvm::call_once(g_once_flag, []() {
 
-    // When locating executables, trust the DEVELOPER_DIR first if it is set
+    // When locating executables, trust the DEVELOPER_DIR first if it is
+    // set
     FileSpec xcode_contents_dir = GetXcodeContentsPath();
     if (xcode_contents_dir) {
       FileSpec xcode_lldb_resources = xcode_contents_dir;
@@ -1715,8 +1711,8 @@
     }
   });
 
-  // Now search the global list of executable directories for the executable we
-  // are looking for
+  // Now search the global list of executable directories for the
+  // executable we are looking for
   for (const auto &executable_dir : g_executable_dirs) {
     FileSpec executable_file;
     executable_file.GetDirectory() = executable_dir.GetDirectory();
@@ -1730,19 +1726,18 @@
 
 lldb_private::Status
 PlatformDarwin::LaunchProcess(lldb_private::ProcessLaunchInfo &launch_info) {
-  // Starting in Fall 2016 OSes, NSLog messages only get mirrored to stderr
-  // if the OS_ACTIVITY_DT_MODE environment variable is set.  (It doesn't
-  // require any specific value; rather, it just needs to exist).
-  // We will set it here as long as the IDE_DISABLED_OS_ACTIVITY_DT_MODE flag
-  // is not set.  Xcode makes use of IDE_DISABLED_OS_ACTIVITY_DT_MODE to tell
-  // LLDB *not* to muck with the OS_ACTIVITY_DT_MODE flag when they
-  // specifically want it unset.
+  // Starting in Fall 2016 OSes, NSLog messages only get mirrored to
+  // stderr if the OS_ACTIVITY_DT_MODE environment variable is set.  (It
+  // doesn't require any specific value; rather, it just needs to exist).
+  // We will set it here as long as the IDE_DISABLED_OS_ACTIVITY_DT_MODE
+  // flag is not set.  Xcode makes use of IDE_DISABLED_OS_ACTIVITY_DT_MODE
+  // to tell LLDB *not* to muck with the OS_ACTIVITY_DT_MODE flag when
+  // they specifically want it unset.
   const char *disable_env_var = "IDE_DISABLED_OS_ACTIVITY_DT_MODE";
   auto &env_vars = launch_info.GetEnvironment();
   if (!env_vars.count(disable_env_var)) {
-    // We want to make sure that OS_ACTIVITY_DT_MODE is set so that
-    // we get os_log and NSLog messages mirrored to the target process
-    // stderr.
+    // We want to make sure that OS_ACTIVITY_DT_MODE is set so that we get
+    // os_log and NSLog messages mirrored to the target process stderr.
     env_vars.try_emplace("OS_ACTIVITY_DT_MODE", "enable");
   }
 
@@ -1757,7 +1752,8 @@
                                                    ModuleSP *old_module_sp_ptr, bool *did_create_ptr)
 {
   const FileSpec &platform_file = module_spec.GetFileSpec();
-  // See if the file is present in any of the module_search_paths_ptr directories.
+  // See if the file is present in any of the module_search_paths_ptr
+  // directories.
   if (!module_sp && module_search_paths_ptr && platform_file) {
     // create a vector of all the file / directory names in platform_file
     // e.g. this might be
@@ -1784,10 +1780,10 @@
       Log *log_verbose = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log_verbose)
           log_verbose->Printf ("PlatformRemoteDarwinDevice::GetSharedModule searching for binary in search-path %s", module_search_paths_ptr->GetFileSpecAtIndex(i).GetPath().c_str());
-      // Create a new FileSpec with this module_search_paths_ptr
-      // plus just the filename ("UIFoundation"), then the parent
-      // dir plus filename ("UIFoundation.framework/UIFoundation")
-      // etc - up to four names (to handle "Foo.framework/Contents/MacOS/Foo")
+      // Create a new FileSpec with this module_search_paths_ptr plus just
+      // the filename ("UIFoundation"), then the parent dir plus filename
+      // ("UIFoundation.framework/UIFoundation") etc - up to four names
+      // (to handle "Foo.framework/Contents/MacOS/Foo")
 
       for (size_t j = 0; j < 4 && j < path_parts_size - 1; ++j) {
         FileSpec path_to_try(module_search_paths_ptr->GetFileSpecAtIndex(i));
@@ -1800,9 +1796,8 @@
         //   [2] PrivateFrameworks
         //
         // and if 'j' is 2, we want to append path_parts[1] and then
-        // path_parts[0], aka
-        // 'UIFoundation.framework/UIFoundation', to the module_search_paths_ptr
-        // path.
+        // path_parts[0], aka 'UIFoundation.framework/UIFoundation', to
+        // the module_search_paths_ptr path.
 
         for (int k = j; k >= 0; --k) {
           path_to_try.AppendPathComponent(path_parts[k]);
Index: source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp
===================================================================
--- source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp
+++ source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp
@@ -91,12 +91,11 @@
                 __FUNCTION__, force ? "true" : "false", arch_name, triple_cstr);
   }
 
-  // This is a special plugin that we don't want to activate just based on an
-  // ArchSpec for normal
-  // userland debugging.  It is only useful in kernel debug sessions and the
-  // DynamicLoaderDarwinPlugin
-  // (or a user doing 'platform select') will force the creation of this
-  // Platform plugin.
+  // This is a special plugin that we don't want to activate just based on
+  // an ArchSpec for normal userland debugging.  It is only useful in
+  // kernel debug sessions and the DynamicLoaderDarwinPlugin (or a user
+  // doing 'platform select') will force the creation of this Platform
+  // plugin.
   if (force == false) {
     if (log)
       log->Printf("PlatformDarwinKernel::%s() aborting creation of platform "
@@ -115,9 +114,9 @@
       create = true;
       break;
 
-    // Only accept "unknown" for vendor if the host is Apple and
-    // it "unknown" wasn't specified (it was just returned because it
-    // was NOT specified)
+    // Only accept "unknown" for vendor if the host is Apple and it
+    // "unknown" wasn't specified (it was just returned because it was NOT
+    // specified)
     case llvm::Triple::UnknownArch:
       create = !arch->TripleVendorWasSpecified();
       break;
@@ -133,9 +132,9 @@
       case llvm::Triple::WatchOS:
       case llvm::Triple::TvOS:
         break;
-      // Only accept "vendor" for vendor if the host is Apple and
-      // it "unknown" wasn't specified (it was just returned because it
-      // was NOT specified)
+      // Only accept "vendor" for vendor if the host is Apple and it
+      // "unknown" wasn't specified (it was just returned because it was
+      // NOT specified)
       case llvm::Triple::UnknownOS:
         create = !arch->TripleOSWasSpecified();
         break;
@@ -336,16 +335,14 @@
   }
 }
 
-// Populate the m_search_directories vector with directories we should search
-// for kernel & kext binaries.
+// Populate the m_search_directories vector with directories we should
+// search for kernel & kext binaries.
 
 void PlatformDarwinKernel::CollectKextAndKernelDirectories() {
-  // Differentiate between "ios debug session" and "mac debug session" so we
-  // don't index
-  // kext bundles that won't be used in this debug session.  If this is an ios
-  // kext debug
-  // session, looking in /System/Library/Extensions is a waste of stat()s, for
-  // example.
+  // Differentiate between "ios debug session" and "mac debug session" so
+  // we don't index kext bundles that won't be used in this debug session.
+  // If this is an ios kext debug session, looking in
+  // /System/Library/Extensions is a waste of stat()s, for example.
 
   // DeveloperDirectory is something like
   // "/Applications/Xcode.app/Contents/Developer"
@@ -368,8 +365,8 @@
 
   AddSDKSubdirsToSearchPaths("/Volumes/KernelDebugKit");
   AddSDKSubdirsToSearchPaths("/AppleInternal/Developer/KDKs");
-  // The KDKs distributed from Apple installed on external
-  // developer systems may be in directories like
+  // The KDKs distributed from Apple installed on external developer
+  // systems may be in directories like
   // /Library/Developer/KDKs/KDK_10.10_14A298i.kdk
   AddSDKSubdirsToSearchPaths("/Library/Developer/KDKs");
 
@@ -381,7 +378,8 @@
 
   GetUserSpecifiedDirectoriesToSearch();
 
-  // Add simple directory /Applications/Xcode.app/Contents/Developer/../Symbols
+  // Add simple directory
+  // /Applications/Xcode.app/Contents/Developer/../Symbols
   FileSpec possible_dir(developer_dir + "/../Symbols", true);
   if (llvm::sys::fs::is_directory(possible_dir.GetPath()))
     m_search_directories.push_back(possible_dir);
@@ -418,7 +416,8 @@
       thisp->m_search_directories.push_back(testdir);
   }
 
-  // Look for kernel binaries in the top level directory, without any recursion
+  // Look for kernel binaries in the top level directory, without any
+  // recursion
   thisp->m_search_directories_no_recursing.push_back(
       FileSpec(dir + "/", false));
 }
@@ -434,7 +433,8 @@
                                this);
 }
 
-// Helper function to find *.sdk and *.kdk directories in a given directory.
+// Helper function to find *.sdk and *.kdk directories in a given
+// directory.
 FileSpec::EnumerateDirectoryResult
 PlatformDarwinKernel::FindKDKandSDKDirectoriesInDirectory(
     void *baton, llvm::sys::fs::file_type ft, const FileSpec &file_spec) {
@@ -450,9 +450,8 @@
   return FileSpec::eEnumerateDirectoryResultNext;
 }
 
-// Recursively search trough m_search_directories looking for
-// kext and kernel binaries, adding files found to the appropriate
-// lists.
+// Recursively search trough m_search_directories looking for kext and
+// kernel binaries, adding files found to the appropriate lists.
 void PlatformDarwinKernel::SearchForKextsAndKernelsRecursively() {
   const uint32_t num_dirs = m_search_directories.size();
   for (uint32_t i = 0; i < num_dirs; i++) {
@@ -476,13 +475,11 @@
   }
 }
 
-// We're only doing a filename match here.  We won't try opening the file to see
-// if it's really
-// a kernel or not until we need to find a kernel of a given UUID.  There's no
-// cheap way to find
-// the UUID of a file (or if it's a Mach-O binary at all) without creating a
-// whole Module for
-// the file and throwing it away if it's not wanted.
+// We're only doing a filename match here.  We won't try opening the file
+// to see if it's really a kernel or not until we need to find a kernel of
+// a given UUID.  There's no cheap way to find the UUID of a file (or if
+// it's a Mach-O binary at all) without creating a whole Module for the
+// file and throwing it away if it's not wanted.
 //
 // Recurse into any subdirectories found.
 
@@ -650,8 +647,8 @@
   return false;
 }
 
-// Given a FileSpec of /dir/dir/mach.development.t7004
-// Return true if a dSYM exists next to it:
+// Given a FileSpec of /dir/dir/mach.development.t7004 Return true if a
+// dSYM exists next to it:
 //    /dir/dir/mach.development.t7004.dSYM
 bool PlatformDarwinKernel::KernelHasdSYMSibling(const FileSpec &kernel_binary) {
   FileSpec kernel_dsym = kernel_binary;
@@ -694,7 +691,7 @@
       }
     }
 
-    // Give the generic methods, including possibly calling into 
+    // Give the generic methods, including possibly calling into
     // DebugSymbols framework on macOS systems, a chance.
     error = PlatformDarwin::GetSharedModule(module_spec, process, module_sp,
                                            module_search_paths_ptr,
@@ -749,7 +746,7 @@
       }
     }
 
-    // Give the generic methods, including possibly calling into 
+    // Give the generic methods, including possibly calling into
     // DebugSymbols framework on macOS systems, a chance.
     error = PlatformDarwin::GetSharedModule(module_spec, process, module_sp,
                                             module_search_paths_ptr,
@@ -802,12 +799,10 @@
       exe_spec.GetArchitecture() = arch;
     }
 
-    // First try to create a ModuleSP with the file / arch and see if the UUID
-    // matches.
-    // If that fails (this exec file doesn't have the correct uuid), don't call
-    // GetSharedModule
-    // (which may call in to the DebugSymbols framework and therefore can be
-    // slow.)
+    // First try to create a ModuleSP with the file / arch and see if the
+    // UUID matches. If that fails (this exec file doesn't have the
+    // correct uuid), don't call GetSharedModule (which may call in to the
+    // DebugSymbols framework and therefore can be slow.)
     ModuleSP module_sp(new Module(exe_spec));
     if (module_sp && module_sp->GetObjectFile() &&
         module_sp->MatchesModuleSpec(exe_spec)) {
@@ -851,17 +846,14 @@
 
 #else // __APPLE__
 
-// Since DynamicLoaderDarwinKernel is compiled in for all systems, and relies on
-// PlatformDarwinKernel for the plug-in name, we compile just the plug-in name
-// in
-// here to avoid issues. We are tracking an internal bug to resolve this issue
-// by
-// either not compiling in DynamicLoaderDarwinKernel for non-apple builds, or to
-// make
-// PlatformDarwinKernel build on all systems. PlatformDarwinKernel is currently
-// not
-// compiled on other platforms due to the use of the Mac-specific
-// source/Host/macosx/cfcpp utilities.
+// Since DynamicLoaderDarwinKernel is compiled in for all systems, and
+// relies on PlatformDarwinKernel for the plug-in name, we compile just
+// the plug-in name in here to avoid issues. We are tracking an internal
+// bug to resolve this issue by either not compiling in
+// DynamicLoaderDarwinKernel for non-apple builds, or to make
+// PlatformDarwinKernel build on all systems. PlatformDarwinKernel is
+// currently not compiled on other platforms due to the use of the Mac-
+// specific source/Host/macosx/cfcpp utilities.
 
 lldb_private::ConstString PlatformDarwinKernel::GetPluginNameStatic() {
   static lldb_private::ConstString g_name("darwin-kernel");
Index: source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp
===================================================================
--- source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp
+++ source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp
@@ -91,9 +91,9 @@
       break;
 
 #if defined(__APPLE__)
-    // Only accept "unknown" for vendor if the host is Apple and
-    // it "unknown" wasn't specified (it was just returned because it
-    // was NOT specified)
+    // Only accept "unknown" for vendor if the host is Apple and it
+    // "unknown" wasn't specified (it was just returned because it was NOT
+    // specified)
     case llvm::Triple::UnknownArch:
       create = !arch->TripleVendorWasSpecified();
       break;
@@ -109,9 +109,9 @@
       case llvm::Triple::MacOSX:
         break;
 #if defined(__APPLE__)
-      // Only accept "vendor" for vendor if the host is Apple and
-      // it "unknown" wasn't specified (it was just returned because it
-      // was NOT specified)
+      // Only accept "vendor" for vendor if the host is Apple and it
+      // "unknown" wasn't specified (it was just returned because it was
+      // NOT specified)
       case llvm::Triple::UnknownOS:
         create = !arch->TripleOSWasSpecified();
         break;
@@ -180,8 +180,8 @@
           xcode_contents_path = fspec.GetPath();
           size_t pos = xcode_contents_path.find("/Xcode.app/Contents/");
           if (pos != std::string::npos) {
-            // LLDB.framework is inside an Xcode app bundle, we can locate the
-            // SDK from here
+            // LLDB.framework is inside an Xcode app bundle, we can locate
+            // the SDK from here
             xcode_contents_path.erase(pos + strlen("/Xcode.app/Contents/"));
           } else {
             xcode_contents_path.clear();
Index: source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.cpp
===================================================================
--- source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.cpp
+++ source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.cpp
@@ -98,9 +98,9 @@
         break;
 
 #if defined(__APPLE__)
-      // Only accept "unknown" for the vendor if the host is Apple and
-      // it "unknown" wasn't specified (it was just returned because it
-      // was NOT specified)
+      // Only accept "unknown" for the vendor if the host is Apple and it
+      // "unknown" wasn't specified (it was just returned because it was
+      // NOT specified)
       case llvm::Triple::UnknownArch:
         create = !arch->TripleVendorWasSpecified();
         break;
Index: source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.cpp
===================================================================
--- source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.cpp
+++ source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.cpp
@@ -93,9 +93,9 @@
         break;
 
 #if defined(__APPLE__)
-      // Only accept "unknown" for the vendor if the host is Apple and
-      // it "unknown" wasn't specified (it was just returned because it
-      // was NOT specified)
+      // Only accept "unknown" for the vendor if the host is Apple and it
+      // "unknown" wasn't specified (it was just returned because it was
+      // NOT specified)
       case llvm::Triple::UnknownArch:
         create = !arch->TripleVendorWasSpecified();
         break;
@@ -123,8 +123,8 @@
 
 #if defined(__APPLE__) &&                                                      \
     (defined(__arm__) || defined(__arm64__) || defined(__aarch64__))
-  // If lldb is running on a watch, this isn't a RemoteWatch environment; it's a
-  // local system environment.
+  // If lldb is running on a watch, this isn't a RemoteWatch environment;
+  // it's a local system environment.
   if (force == false) {
     create = false;
   }
Index: source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.cpp
===================================================================
--- source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.cpp
+++ source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.cpp
@@ -82,9 +82,8 @@
 
   ModuleSpec resolved_module_spec(ms);
 
-  // Resolve any executable within a bundle on MacOSX
-  // TODO: verify that this handles shallow bundles, if not then implement one
-  // ourselves
+  // Resolve any executable within a bundle on MacOSX TODO: verify that
+  // this handles shallow bundles, if not then implement one ourselves
   Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
 
   if (resolved_module_spec.GetFileSpec().Exists()) {
@@ -99,7 +98,8 @@
     }
     // No valid architecture was specified or the exact ARM slice wasn't
     // found so ask the platform for the architectures that we should be
-    // using (in the correct order) and see if we can find a match that way
+    // using (in the correct order) and see if we can find a match that
+    // way
     StreamString arch_names;
     for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
              idx, resolved_module_spec.GetArchitecture());
@@ -153,7 +153,8 @@
   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
   if (m_sdk_directory_infos.empty()) {
-    // A --sysroot option was supplied - add it to our list of SDKs to check
+    // A --sysroot option was supplied - add it to our list of SDKs to
+    // check
     if (m_sdk_sysroot) {
       FileSpec sdk_sysroot_fspec(m_sdk_sysroot.GetCString(), true);
       const SDKDirectoryInfo sdk_sysroot_directory_info(sdk_sysroot_fspec);
@@ -182,9 +183,9 @@
                                    GetContainedFilesIntoVectorOfStringsCallback,
                                    &builtin_sdk_directory_infos);
 
-      // Only add SDK directories that have symbols in them, some SDKs only
-      // contain
-      // developer disk images and no symbols, so they aren't useful to us.
+      // Only add SDK directories that have symbols in them, some SDKs
+      // only contain developer disk images and no symbols, so they aren't
+      // useful to us.
       FileSpec sdk_symbols_symlink_fspec;
       for (const auto &sdk_directory_info : builtin_sdk_directory_infos) {
         sdk_symbols_symlink_fspec = sdk_directory_info.directory;
@@ -244,8 +245,8 @@
   if (UpdateSDKDirectoryInfosIfNeeded()) {
     const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
 
-    // Check to see if the user specified a build string. If they did, then
-    // be sure to match it.
+    // Check to see if the user specified a build string. If they did,
+    // then be sure to match it.
     std::vector<bool> check_sdk_info(num_sdk_infos, true);
     ConstString build(m_sdk_build);
     if (build) {
@@ -287,7 +288,8 @@
         }
       }
     } else if (build) {
-      // No version, just a build number, search for the first one that matches
+      // No version, just a build number, search for the first one that
+      // matches
       for (i = 0; i < num_sdk_infos; ++i)
         if (check_sdk_info[i])
           return &m_sdk_directory_infos[i];
@@ -331,13 +333,15 @@
       m_device_support_directory.assign(device_support_dir);
       m_device_support_directory.append(platform_dir.c_str());
     } else {
-      // Assign a single NULL character so we know we tried to find the device
-      // support directory and we don't keep trying to find it over and over.
+      // Assign a single NULL character so we know we tried to find the
+      // device support directory and we don't keep trying to find it over
+      // and over.
       m_device_support_directory.assign(1, '\0');
     }
   }
-  // We should have put a single NULL character into m_device_support_directory
-  // or it should have a valid path if the code gets here
+  // We should have put a single NULL character into
+  // m_device_support_directory or it should have a valid path if the code
+  // gets here
   assert(m_device_support_directory.empty() == false);
   if (m_device_support_directory[0])
     return m_device_support_directory.c_str();
@@ -360,14 +364,15 @@
         return m_device_support_directory_for_os_version.c_str();
       }
     } else {
-      // Assign a single NULL character so we know we tried to find the device
-      // support directory and we don't keep trying to find it over and over.
+      // Assign a single NULL character so we know we tried to find the
+      // device support directory and we don't keep trying to find it over
+      // and over.
       m_device_support_directory_for_os_version.assign(1, '\0');
     }
   }
   // We should have put a single NULL character into
-  // m_device_support_directory_for_os_version
-  // or it should have a valid path if the code gets here
+  // m_device_support_directory_for_os_version or it should have a valid
+  // path if the code gets here
   assert(m_device_support_directory_for_os_version.empty() == false);
   if (m_device_support_directory_for_os_version[0])
     return m_device_support_directory_for_os_version.c_str();
@@ -403,9 +408,8 @@
     local_file.Clear();
 
     if (!sdkroot_path.empty() && platform_file_path && platform_file_path[0]) {
-      // We may need to interpose "/Symbols/" or "/Symbols.Internal/" between
-      // the
-      // SDK root directory and the file path.
+      // We may need to interpose "/Symbols/" or "/Symbols.Internal/"
+      // between the SDK root directory and the file path.
 
       const char *paths_to_try[] = {"Symbols", "", "Symbols.Internal", nullptr};
       for (size_t i = 0; paths_to_try[i] != nullptr; i++) {
@@ -492,10 +496,9 @@
     const ModuleSpec &module_spec, Process *process, ModuleSP &module_sp,
     const FileSpecList *module_search_paths_ptr, ModuleSP *old_module_sp_ptr,
     bool *did_create_ptr) {
-  // For iOS, the SDK files are all cached locally on the host
-  // system. So first we ask for the file in the cached SDK,
-  // then we attempt to get a shared module for the right architecture
-  // with the right UUID.
+  // For iOS, the SDK files are all cached locally on the host system. So
+  // first we ask for the file in the cached SDK, then we attempt to get a
+  // shared module for the right architecture with the right UUID.
   const FileSpec &platform_file = module_spec.GetFileSpec();
   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
 
@@ -510,8 +513,7 @@
     const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
 
     // If we are connected we migth be able to correctly deduce the SDK
-    // directory
-    // using the OS build.
+    // directory using the OS build.
     const uint32_t connected_sdk_idx = GetConnectedSDKIndex();
     if (connected_sdk_idx < num_sdk_infos) {
       LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
@@ -528,8 +530,8 @@
       }
     }
 
-    // Try the last SDK index if it is set as most files from an SDK
-    // will tend to be valid in that same SDK.
+    // Try the last SDK index if it is set as most files from an SDK will
+    // tend to be valid in that same SDK.
     if (m_last_module_sdk_idx < num_sdk_infos) {
       LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
                 m_sdk_directory_infos[m_last_module_sdk_idx].directory);
@@ -544,8 +546,8 @@
       }
     }
 
-    // First try for an exact match of major, minor and update:
-    // If a particalar SDK version was specified via --version or --build, look
+    // First try for an exact match of major, minor and update: If a
+    // particalar SDK version was specified via --version or --build, look
     // for a match on disk.
     const SDKDirectoryInfo *current_sdk_info =
         GetSDKDirectoryForCurrentOSVersion();
@@ -570,20 +572,20 @@
     // Second try all SDKs that were found.
     for (uint32_t sdk_idx = 0; sdk_idx < num_sdk_infos; ++sdk_idx) {
       if (m_last_module_sdk_idx == sdk_idx) {
-        // Skip the last module SDK index if we already searched
-        // it above
+        // Skip the last module SDK index if we already searched it above
         continue;
       }
       LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
                 m_sdk_directory_infos[sdk_idx].directory);
       if (GetFileInSDK(platform_file_path, sdk_idx,
                        platform_module_spec.GetFileSpec())) {
-        // printf ("sdk[%u]: '%s'\n", sdk_idx, local_file.GetPath().c_str());
+        // printf ("sdk[%u]: '%s'\n", sdk_idx,
+        // local_file.GetPath().c_str());
 
         error = ResolveExecutable(platform_module_spec, module_sp, NULL);
         if (module_sp) {
-          // Remember the index of the last SDK that we found a file
-          // in in case the wrong SDK was selected.
+          // Remember the index of the last SDK that we found a file in in
+          // case the wrong SDK was selected.
           m_last_module_sdk_idx = sdk_idx;
           error.Clear();
           return error;
@@ -594,8 +596,8 @@
   // Not the module we are looking for... Nothing to see here...
   module_sp.reset();
 
-  // This may not be an SDK-related module.  Try whether we can bring in the
-  // thing to our local cache.
+  // This may not be an SDK-related module.  Try whether we can bring in
+  // the thing to our local cache.
   error = GetSharedModuleWithLocalCache(module_spec, module_sp,
                                         module_search_paths_ptr,
                                         old_module_sp_ptr, did_create_ptr);
Index: source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp
===================================================================
--- source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp
+++ source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp
@@ -88,9 +88,9 @@
         break;
 
 #if defined(__APPLE__)
-      // Only accept "unknown" for the vendor if the host is Apple and
-      // it "unknown" wasn't specified (it was just returned because it
-      // was NOT specified)
+      // Only accept "unknown" for the vendor if the host is Apple and it
+      // "unknown" wasn't specified (it was just returned because it was
+      // NOT specified)
       case llvm::Triple::UnknownArch:
         create = !arch->TripleVendorWasSpecified();
         break;
Index: source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp
===================================================================
--- source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp
+++ source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp
@@ -91,9 +91,9 @@
         break;
 
 #if defined(__APPLE__)
-      // Only accept "unknown" for the vendor if the host is Apple and
-      // it "unknown" wasn't specified (it was just returned because it
-      // was NOT specified)
+      // Only accept "unknown" for the vendor if the host is Apple and it
+      // "unknown" wasn't specified (it was just returned because it was
+      // NOT specified)
       case llvm::Triple::UnknownArch:
         create = !arch->TripleVendorWasSpecified();
         break;
@@ -112,9 +112,9 @@
           break;
 
 #if defined(__APPLE__)
-        // Only accept "unknown" for the OS if the host is Apple and
-        // it "unknown" wasn't specified (it was just returned because it
-        // was NOT specified)
+        // Only accept "unknown" for the OS if the host is Apple and it
+        // "unknown" wasn't specified (it was just returned because it was
+        // NOT specified)
         case llvm::Triple::UnknownOS:
           create = !arch->TripleOSWasSpecified();
           break;
@@ -185,15 +185,14 @@
 
   ModuleSpec resolved_module_spec(module_spec);
 
-  // If we have "ls" as the exe_file, resolve the executable loation based on
-  // the current path variables
-  // TODO: resolve bare executables in the Platform SDK
+  // If we have "ls" as the exe_file, resolve the executable loation based
+  // on the current path variables TODO: resolve bare executables in the
+  // Platform SDK
   //    if (!resolved_exe_file.Exists())
   //        resolved_exe_file.ResolveExecutableLocation ();
 
-  // Resolve any executable within a bundle on MacOSX
-  // TODO: verify that this handles shallow bundles, if not then implement one
-  // ourselves
+  // Resolve any executable within a bundle on MacOSX TODO: verify that
+  // this handles shallow bundles, if not then implement one ourselves
   Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
 
   if (resolved_module_spec.GetFileSpec().Exists()) {
@@ -207,7 +206,8 @@
     }
     // No valid architecture was specified or the exact ARM slice wasn't
     // found so ask the platform for the architectures that we should be
-    // using (in the correct order) and see if we can find a match that way
+    // using (in the correct order) and see if we can find a match that
+    // way
     StreamString arch_names;
     ArchSpec platform_arch;
     for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
@@ -293,13 +293,14 @@
         return m_sdk_directory.c_str();
       }
     }
-    // Assign a single NULL character so we know we tried to find the device
-    // support directory and we don't keep trying to find it over and over.
+    // Assign a single NULL character so we know we tried to find the
+    // device support directory and we don't keep trying to find it over
+    // and over.
     m_sdk_directory.assign(1, '\0');
   }
 
-  // We should have put a single NULL character into m_sdk_directory
-  // or it should have a valid path if the code gets here
+  // We should have put a single NULL character into m_sdk_directory or it
+  // should have a valid path if the code gets here
   assert(m_sdk_directory.empty() == false);
   if (m_sdk_directory[0])
     return m_sdk_directory.c_str();
@@ -342,10 +343,9 @@
     const ModuleSpec &module_spec, Process *process, ModuleSP &module_sp,
     const FileSpecList *module_search_paths_ptr, ModuleSP *old_module_sp_ptr,
     bool *did_create_ptr) {
-  // For iOS, the SDK files are all cached locally on the host
-  // system. So first we ask for the file in the cached SDK,
-  // then we attempt to get a shared module for the right architecture
-  // with the right UUID.
+  // For iOS, the SDK files are all cached locally on the host system. So
+  // first we ask for the file in the cached SDK, then we attempt to get a
+  // shared module for the right architecture with the right UUID.
   Status error;
   ModuleSpec platform_module_spec(module_spec);
   const FileSpec &platform_file = module_spec.GetFileSpec();
@@ -409,14 +409,14 @@
         if (arch.IsValid()) {
           if (idx == 2)
             arch.GetTriple().setOS(llvm::Triple::IOS);
-          // 32/64: return "i386-apple-ios" for architecture 2
-          // 32/64: return "i386-apple-macosx" for architecture 3
+          // 32/64: return "i386-apple-ios" for architecture 2 32/64:
+          // return "i386-apple-macosx" for architecture 3
           return true;
         }
       }
     } else if (idx == 1) {
-      // This macosx platform supports only 32 bit, so return the *-apple-macosx
-      // version
+      // This macosx platform supports only 32 bit, so return the *-apple-
+      // macosx version
       arch = platform_arch;
       return true;
     }
Index: source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp
===================================================================
--- source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp
+++ source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp
@@ -30,8 +30,8 @@
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
-// Define these constants from NetBSD mman.h for use when targeting
-// remote netbsd systems even when host has different values.
+// Define these constants from NetBSD mman.h for use when targeting remote
+// netbsd systems even when host has different values.
 #define MAP_PRIVATE 0x0002
 #define MAP_ANON 0x1000
 
@@ -134,7 +134,8 @@
         arch = hostArch;
         return arch.IsValid();
       } else if (idx == 1) {
-        // If the default host architecture is 64-bit, look for a 32-bit variant
+        // If the default host architecture is 64-bit, look for a 32-bit
+        // variant
         if (hostArch.IsValid() && hostArch.GetTriple().isArch64Bit()) {
           arch = HostInfo::GetArchitecture(HostInfo::eArchKind32);
           return arch.IsValid();
@@ -159,13 +160,11 @@
     default:
       return false;
     }
-    // Leave the vendor as "llvm::Triple:UnknownVendor" and don't specify the
-    // vendor by
-    // calling triple.SetVendorName("unknown") so that it is a "unspecified
-    // unknown".
-    // This means when someone calls triple.GetVendorName() it will return an
-    // empty string
-    // which indicates that the vendor can be set when two architectures are
+    // Leave the vendor as "llvm::Triple:UnknownVendor" and don't specify
+    // the vendor by calling triple.SetVendorName("unknown") so that it is
+    // a "unspecified unknown". This means when someone calls
+    // triple.GetVendorName() it will return an empty string which
+    // indicates that the vendor can be set when two architectures are
     // merged
 
     // Now set the triple into "arch" and return true
@@ -179,9 +178,9 @@
   Platform::GetStatus(strm);
 
 #ifndef LLDB_DISABLE_POSIX
-  // Display local kernel information only when we are running in host mode.
-  // Otherwise, we would end up printing non-NetBSD information (when running
-  // on Mac OS for example).
+  // Display local kernel information only when we are running in host
+  // mode. Otherwise, we would end up printing non-NetBSD information
+  // (when running on Mac OS for example).
   if (IsHost()) {
     struct utsname un;
 
@@ -239,9 +238,9 @@
   }
 }
 
-// For local debugging, NetBSD will override the debug logic to use llgs-launch
-// rather than lldb-launch, llgs-attach.  This differs from current lldb-launch,
-// debugserver-attach approach on MacOSX.
+// For local debugging, NetBSD will override the debug logic to use llgs-
+// launch rather than lldb-launch, llgs-attach.  This differs from current
+// lldb-launch, debugserver-attach approach on MacOSX.
 lldb::ProcessSP
 PlatformNetBSD::DebugProcess(ProcessLaunchInfo &launch_info, Debugger &debugger,
                              Target *target, // Can be NULL, if NULL create a new
@@ -255,8 +254,8 @@
     return PlatformPOSIX::DebugProcess(launch_info, debugger, target, error);
 
   //
-  // For local debugging, we'll insist on having ProcessGDBRemote create the
-  // process.
+  // For local debugging, we'll insist on having ProcessGDBRemote create
+  // the process.
   //
 
   ProcessSP process_sp;
@@ -264,9 +263,9 @@
   // Make sure we stop at the entry point
   launch_info.GetFlags().Set(eLaunchFlagDebug);
 
-  // We always launch the process we are going to debug in a separate process
-  // group, since then we can handle ^C interrupts ourselves w/o having to worry
-  // about the target getting them as well.
+  // We always launch the process we are going to debug in a separate
+  // process group, since then we can handle ^C interrupts ourselves w/o
+  // having to worry about the target getting them as well.
   launch_info.SetLaunchInSeparateProcessGroup(true);
 
   // Ensure we have a target.
@@ -337,8 +336,8 @@
       LLDB_LOG(log, "pid {0} state {0}", process_sp->GetID(), state);
     }
 
-    // Hook up process PTY if we have one (which we should for local debugging
-    // with llgs).
+    // Hook up process PTY if we have one (which we should for local
+    // debugging with llgs).
     int pty_fd = launch_info.GetPTY().ReleaseMasterFileDescriptor();
     if (pty_fd != PseudoTerminal::invalid_fd) {
       process_sp->SetSTDIOFileDescriptor(pty_fd);
@@ -347,8 +346,8 @@
       LLDB_LOG(log, "not using process STDIO pty");
   } else {
     LLDB_LOG(log, "process launch failed: {0}", error);
-    // FIXME figure out appropriate cleanup here.  Do we delete the target? Do
-    // we delete the process?  Does our caller do that?
+    // FIXME figure out appropriate cleanup here.  Do we delete the
+    // target? Do we delete the process?  Does our caller do that?
   }
 
   return process_sp;
Index: source/Plugins/Platform/OpenBSD/PlatformOpenBSD.cpp
===================================================================
--- source/Plugins/Platform/OpenBSD/PlatformOpenBSD.cpp
+++ source/Plugins/Platform/OpenBSD/PlatformOpenBSD.cpp
@@ -58,9 +58,9 @@
       break;
 
 #if defined(__OpenBSD__)
-    // Only accept "unknown" for the OS if the host is BSD and
-    // it "unknown" wasn't specified (it was just returned because it
-    // was NOT specified)
+    // Only accept "unknown" for the OS if the host is BSD and it
+    // "unknown" wasn't specified (it was just returned because it was NOT
+    // specified)
     case llvm::Triple::OSType::UnknownOS:
       create = !arch->TripleOSWasSpecified();
       break;
@@ -166,13 +166,11 @@
     default:
       return false;
     }
-    // Leave the vendor as "llvm::Triple:UnknownVendor" and don't specify the
-    // vendor by
-    // calling triple.SetVendorName("unknown") so that it is a "unspecified
-    // unknown".
-    // This means when someone calls triple.GetVendorName() it will return an
-    // empty string
-    // which indicates that the vendor can be set when two architectures are
+    // Leave the vendor as "llvm::Triple:UnknownVendor" and don't specify
+    // the vendor by calling triple.SetVendorName("unknown") so that it is
+    // a "unspecified unknown". This means when someone calls
+    // triple.GetVendorName() it will return an empty string which
+    // indicates that the vendor can be set when two architectures are
     // merged
 
     // Now set the triple into "arch" and return true
@@ -186,9 +184,9 @@
   Platform::GetStatus(strm);
 
 #ifndef LLDB_DISABLE_POSIX
-  // Display local kernel information only when we are running in host mode.
-  // Otherwise, we would end up printing non-OpenBSD information (when running
-  // on Mac OS for example).
+  // Display local kernel information only when we are running in host
+  // mode. Otherwise, we would end up printing non-OpenBSD information
+  // (when running on Mac OS for example).
   if (IsHost()) {
     struct utsname un;
 
Index: source/Plugins/Platform/POSIX/PlatformPOSIX.cpp
===================================================================
--- source/Plugins/Platform/POSIX/PlatformPOSIX.cpp
+++ source/Plugins/Platform/POSIX/PlatformPOSIX.cpp
@@ -129,8 +129,8 @@
   ModuleSpec resolved_module_spec(module_spec);
 
   if (IsHost()) {
-    // If we have "ls" as the exe_file, resolve the executable location based on
-    // the current path variables
+    // If we have "ls" as the exe_file, resolve the executable location
+    // based on the current path variables
     if (!resolved_module_spec.GetFileSpec().Exists()) {
       resolved_module_spec.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
       resolved_module_spec.GetFileSpec().SetFile(exe_path, true);
@@ -162,8 +162,8 @@
           GetCachedExecutable(resolved_module_spec, exe_module_sp,
                               module_search_paths_ptr, *m_remote_platform_sp);
     } else {
-      // We may connect to a process and use the provided executable (Don't use
-      // local $PATH).
+      // We may connect to a process and use the provided executable
+      // (Don't use local $PATH).
 
       // Resolve any executable within a bundle on MacOSX
       Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
@@ -183,7 +183,8 @@
       error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
                                           module_search_paths_ptr, nullptr, nullptr);
       if (error.Fail()) {
-        // If we failed, it may be because the vendor and os aren't known. If
+        // If we failed, it may be because the vendor and os aren't known.
+        // If
 	// that is the case, try setting them to the host architecture and give
 	// it another try.
         llvm::Triple &module_triple =
@@ -215,9 +216,9 @@
             resolved_module_spec.GetArchitecture().GetArchitectureName());
       }
     } else {
-      // No valid architecture was specified, ask the platform for
-      // the architectures that we should be using (in the correct order)
-      // and see if we can find a match that way
+      // No valid architecture was specified, ask the platform for the
+      // architectures that we should be using (in the correct order) and
+      // see if we can find a match that way
       StreamString arch_names;
       for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
                idx, resolved_module_spec.GetArchitecture());
@@ -433,8 +434,8 @@
         //                    return Status("unable to perform chown");
         return Status();
       }
-      // if we are still here rsync has failed - let's try the slow way before
-      // giving up
+      // if we are still here rsync has failed - let's try the slow way
+      // before giving up
     }
   }
   return Platform::PutFile(source, destination, uid, gid);
@@ -524,8 +525,8 @@
       Host::RunShellCommand(command.GetData(), NULL, &retcode, NULL, NULL, 60);
       if (retcode == 0)
         return Status();
-      // If we are here, rsync has failed - let's try the slow way before giving
-      // up
+      // If we are here, rsync has failed - let's try the slow way before
+      // giving up
     }
     // open src and dst
     // read/write, read/write, read/write, ...
@@ -696,7 +697,8 @@
 }
 
 const char *PlatformPOSIX::GetUserName(uint32_t uid) {
-  // Check the cache in Platform in case we have already looked this uid up
+  // Check the cache in Platform in case we have already looked this uid
+  // up
   const char *user_name = Platform::GetUserName(uid);
   if (user_name)
     return user_name;
@@ -865,12 +867,11 @@
   ProcessSP process_sp;
 
   if (IsHost()) {
-    // We are going to hand this process off to debugserver which will be in
-    // charge of setting the exit status.
-    // We still need to reap it from lldb but if we let the monitor thread also
-    // set the exit status, we set up a
-    // race between debugserver & us for who will find out about the debugged
-    // process's death.
+    // We are going to hand this process off to debugserver which will be
+    // in charge of setting the exit status. We still need to reap it from
+    // lldb but if we let the monitor thread also set the exit status, we
+    // set up a race between debugserver & us for who will find out about
+    // the debugged process's death.
     launch_info.GetFlags().Set(eLaunchFlagDontSetExitStatus);
     process_sp = Platform::DebugProcess(launch_info, debugger, target, error);
   } else {
@@ -932,10 +933,11 @@
 PlatformPOSIX::MakeLoadImageUtilityFunction(ExecutionContext &exe_ctx, 
                                             Status &error)
 {
-  // Remember to prepend this with the prefix from GetLibdlFunctionDeclarations.
-  // The returned values are all in __lldb_dlopen_result for consistency.
-  // The wrapper returns a void * but doesn't use it because
-  // UtilityFunctions don't work with void returns at present.
+  // Remember to prepend this with the prefix from
+  // GetLibdlFunctionDeclarations. The returned values are all in
+  // __lldb_dlopen_result for consistency. The wrapper returns a void *
+  // but doesn't use it because UtilityFunctions don't work with void
+  // returns at present.
   static const char *dlopen_wrapper_code = R"(
   struct __lldb_dlopen_result {
     void *image_ptr;
@@ -990,8 +992,8 @@
   CompilerType clang_char_pointer_type
         = ast->GetBasicType(eBasicTypeChar).GetPointerType();
 
-  // We are passing two arguments, the path to dlopen, and a pointer to the
-  // storage we've made for the result:
+  // We are passing two arguments, the path to dlopen, and a pointer to
+  // the storage we've made for the result:
   value.SetValueType(Value::eValueTypeScalar);
   value.SetCompilerType(clang_void_pointer_type);
   arguments.PushValue(value);
@@ -1037,8 +1039,9 @@
 
   Status utility_error;
   
-  // The UtilityFunction is held in the Process.  Platforms don't track the 
-  // lifespan of the Targets that use them, we can't put this in the Platform.
+  // The UtilityFunction is held in the Process.  Platforms don't track
+  // the  lifespan of the Targets that use them, we can't put this in the
+  // Platform.
   UtilityFunction *dlopen_utility_func 
       = process->GetLoadImageUtilityFunction(this);
   ValueList arguments;
@@ -1048,7 +1051,8 @@
     // Make the UtilityFunction:
     dlopen_utility_func = MakeLoadImageUtilityFunction(exe_ctx, error);
   }
-  // If we couldn't make it, the error will be in error, so we can exit here.
+  // If we couldn't make it, the error will be in error, so we can exit
+  // here.
   if (!dlopen_utility_func)
     return LLDB_INVALID_IMAGE_TOKEN;
     
@@ -1059,8 +1063,8 @@
   }
   arguments = do_dlopen_function->GetArgumentValues();
   
-  // Now insert the path we are searching for and the result structure into
-  // the target.
+  // Now insert the path we are searching for and the result structure
+  // into the target.
   uint32_t permissions = ePermissionsReadable|ePermissionsWritable;
   size_t path_len = path.size() + 1;
   lldb::addr_t path_addr = process->AllocateMemory(path_len, 
@@ -1084,8 +1088,8 @@
     return LLDB_INVALID_IMAGE_TOKEN;
   }
   
-  // Make space for our return structure.  It is two pointers big: the token and
-  // the error string.
+  // Make space for our return structure.  It is two pointers big: the
+  // token and the error string.
   const uint32_t addr_size = process->GetAddressByteSize();
   lldb::addr_t return_addr = process->CallocateMemory(2*addr_size,
                                                       permissions,
@@ -1118,9 +1122,9 @@
     return LLDB_INVALID_IMAGE_TOKEN;
   }
   
-  // Make sure we clean up the args structure.  We can't reuse it because the
-  // Platform lives longer than the process and the Platforms don't get a
-  // signal to clean up cached data when a process goes away.
+  // Make sure we clean up the args structure.  We can't reuse it because
+  // the Platform lives longer than the process and the Platforms don't
+  // get a signal to clean up cached data when a process goes away.
   CleanUp args_cleanup([do_dlopen_function, &exe_ctx, func_args_addr] {
     do_dlopen_function->DeallocateFunctionResults(exe_ctx, func_args_addr);
   });
Index: source/Plugins/Platform/Windows/PlatformWindows.cpp
===================================================================
--- source/Plugins/Platform/Windows/PlatformWindows.cpp
+++ source/Plugins/Platform/Windows/PlatformWindows.cpp
@@ -212,8 +212,8 @@
       error = GetCachedExecutable(resolved_module_spec, exe_module_sp, nullptr,
                                   *m_remote_platform_sp);
     } else {
-      // We may connect to a process and use the provided executable (Don't use
-      // local $PATH).
+      // We may connect to a process and use the provided executable
+      // (Don't use local $PATH).
       if (resolved_module_spec.GetFileSpec().Exists())
         error.Clear();
       else
@@ -237,9 +237,9 @@
             resolved_module_spec.GetArchitecture().GetArchitectureName());
       }
     } else {
-      // No valid architecture was specified, ask the platform for
-      // the architectures that we should be using (in the correct order)
-      // and see if we can find a match that way
+      // No valid architecture was specified, ask the platform for the
+      // architectures that we should be using (in the correct order) and
+      // see if we can find a match that way
       StreamString arch_names;
       for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
                idx, resolved_module_spec.GetArchitecture());
@@ -412,30 +412,26 @@
 ProcessSP PlatformWindows::DebugProcess(ProcessLaunchInfo &launch_info,
                                         Debugger &debugger, Target *target,
                                         Status &error) {
-  // Windows has special considerations that must be followed when launching or
-  // attaching to a process.  The
-  // key requirement is that when launching or attaching to a process, you must
-  // do it from the same the thread
-  // that will go into a permanent loop which will then receive debug events
-  // from the process.  In particular,
-  // this means we can't use any of LLDB's generic mechanisms to do it for us,
-  // because it doesn't have the
-  // special knowledge required for setting up the background thread or passing
-  // the right flags.
+  // Windows has special considerations that must be followed when
+  // launching or attaching to a process.  The key requirement is that
+  // when launching or attaching to a process, you must do it from the
+  // same the thread that will go into a permanent loop which will then
+  // receive debug events from the process.  In particular, this means we
+  // can't use any of LLDB's generic mechanisms to do it for us, because
+  // it doesn't have the special knowledge required for setting up the
+  // background thread or passing the right flags.
   //
-  // Another problem is that that LLDB's standard model for debugging a process
-  // is to first launch it, have
-  // it stop at the entry point, and then attach to it.  In Windows this doesn't
-  // quite work, you have to
-  // specify as an argument to CreateProcess() that you're going to debug the
-  // process.  So we override DebugProcess
-  // here to handle this.  Launch operations go directly to the process plugin,
-  // and attach operations almost go
-  // directly to the process plugin (but we hijack the events first).  In
-  // essence, we encapsulate all the logic
-  // of Launching and Attaching in the process plugin, and
-  // PlatformWindows::DebugProcess is just a pass-through
-  // to get to the process plugin.
+  // Another problem is that that LLDB's standard model for debugging a
+  // process is to first launch it, have it stop at the entry point, and
+  // then attach to it.  In Windows this doesn't quite work, you have to
+  // specify as an argument to CreateProcess() that you're going to debug
+  // the process.  So we override DebugProcess here to handle this.
+  // Launch operations go directly to the process plugin, and attach
+  // operations almost go directly to the process plugin (but we hijack
+  // the events first).  In essence, we encapsulate all the logic of
+  // Launching and Attaching in the process plugin, and
+  // PlatformWindows::DebugProcess is just a pass-through to get to the
+  // process plugin.
 
   if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) {
     // This is a process attach.  Don't need to launch anything.
@@ -496,7 +492,8 @@
 }
 
 const char *PlatformWindows::GetUserName(uint32_t uid) {
-  // Check the cache in Platform in case we have already looked this uid up
+  // Check the cache in Platform in case we have already looked this uid
+  // up
   const char *user_name = Platform::GetUserName(uid);
   if (user_name)
     return user_name;
@@ -538,8 +535,8 @@
   module_sp.reset();
 
   if (IsRemote()) {
-    // If we have a remote platform always, let it try and locate
-    // the shared module first.
+    // If we have a remote platform always, let it try and locate the
+    // shared module first.
     if (m_remote_platform_sp) {
       error = m_remote_platform_sp->GetSharedModule(
           module_spec, process, module_sp, module_search_paths_ptr,
Index: source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp
===================================================================
--- source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp
+++ source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp
@@ -118,9 +118,9 @@
         return error;
       exe_module_sp.reset();
     }
-    // No valid architecture was specified or the exact arch wasn't
-    // found so ask the platform for the architectures that we should be
-    // using (in the correct order) and see if we can find a match that way
+    // No valid architecture was specified or the exact arch wasn't found
+    // so ask the platform for the architectures that we should be using
+    // (in the correct order) and see if we can find a match that way
     StreamString arch_names;
     for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
              idx, resolved_module_spec.GetArchitecture());
@@ -276,9 +276,8 @@
 bool PlatformRemoteGDBServer::SetRemoteWorkingDirectory(
     const FileSpec &working_dir) {
   if (IsConnected()) {
-    // Clear the working directory it case it doesn't get set correctly. This
-    // will
-    // for use to re-read it
+    // Clear the working directory it case it doesn't get set correctly.
+    // This will for use to re-read it
     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
     if (log)
       log->Printf("PlatformRemoteGDBServer::SetRemoteWorkingDirectory('%s')",
@@ -302,7 +301,8 @@
   } else {
     if (args.GetArgumentCount() == 1) {
       m_gdb_client.SetConnection(new ConnectionFileDescriptor());
-      // we're going to reuse the hostname when we connect to the debugserver
+      // we're going to reuse the hostname when we connect to the
+      // debugserver
       int port;
       std::string path;
       const char *url = args.GetArgumentAtIndex(0);
@@ -319,8 +319,8 @@
       if (status == eConnectionStatusSuccess) {
         if (m_gdb_client.HandshakeWithServer(&error)) {
           m_gdb_client.GetHostInfo();
-          // If a working directory was set prior to connecting, send it down
-          // now
+          // If a working directory was set prior to connecting, send it
+          // down now
           if (m_working_dir)
             m_gdb_client.SetWorkingDir(m_working_dir);
         } else {
@@ -504,8 +504,9 @@
         if (target && error.Success()) {
           debugger.GetTargetList().SetSelectedTarget(target);
 
-          // The darwin always currently uses the GDB remote debugger plug-in
-          // so even when debugging locally we are debugging remotely!
+          // The darwin always currently uses the GDB remote debugger
+          // plug-in so even when debugging locally we are debugging
+          // remotely!
           process_sp = target->CreateProcess(
               launch_info.GetListenerForProcess(debugger), "gdb-remote", NULL);
 
@@ -540,10 +541,10 @@
   bool launch_result = false;
   if (remote_triple.getVendor() == llvm::Triple::Apple &&
       remote_triple.getOS() == llvm::Triple::IOS) {
-    // When remote debugging to iOS, we use a USB mux that always talks
-    // to localhost, so we will need the remote debugserver to accept
-    // connections
-    // only from localhost, no matter what our current hostname is
+    // When remote debugging to iOS, we use a USB mux that always talks to
+    // localhost, so we will need the remote debugserver to accept
+    // connections only from localhost, no matter what our current
+    // hostname is
     launch_result =
         m_gdb_client.LaunchGDBServer("127.0.0.1", pid, port, socket_name);
   } else {
@@ -591,8 +592,9 @@
         if (target && error.Success()) {
           debugger.GetTargetList().SetSelectedTarget(target);
 
-          // The darwin always currently uses the GDB remote debugger plug-in
-          // so even when debugging locally we are debugging remotely!
+          // The darwin always currently uses the GDB remote debugger
+          // plug-in so even when debugging locally we are debugging
+          // remotely!
           process_sp = target->CreateProcess(
               attach_info.GetListenerForProcess(debugger), "gdb-remote", NULL);
           if (process_sp) {
@@ -740,8 +742,8 @@
   if (m_remote_signals_sp)
     return m_remote_signals_sp;
 
-  // If packet not implemented or JSON failed to parse,
-  // we'll guess the signal set based on the remote architecture.
+  // If packet not implemented or JSON failed to parse, we'll guess the
+  // signal set based on the remote architecture.
   m_remote_signals_sp = UnixSignals::Create(GetRemoteSystemArchitecture());
 
   StringExtractorGDBRemote response;
Index: source/Plugins/Process/Darwin/CFString.cpp
===================================================================
--- source/Plugins/Process/Darwin/CFString.cpp
+++ source/Plugins/Process/Darwin/CFString.cpp
@@ -91,13 +91,11 @@
   return CFString::UTF8(get(), str);
 }
 
-// Static function that puts a copy of the UTF8 contents of CF_STR into STR
-// and returns the C string pointer that is contained in STR when successful,
-// else
-// NULL is returned. This allows the std::string parameter to own the extracted
-// string,
-// and also allows that string to be returned as a C string pointer that can be
-// used.
+// Static function that puts a copy of the UTF8 contents of CF_STR into
+// STR and returns the C string pointer that is contained in STR when
+// successful, else NULL is returned. This allows the std::string
+// parameter to own the extracted string, and also allows that string to
+// be returned as a C string pointer that can be used.
 
 const char *CFString::UTF8(CFStringRef cf_str, std::string &str) {
   if (cf_str) {
@@ -118,11 +116,11 @@
   return NULL;
 }
 
-// Static function that puts a copy of the file system representation of CF_STR
-// into STR and returns the C string pointer that is contained in STR when
-// successful, else NULL is returned. This allows the std::string parameter
-// to own the extracted string, and also allows that string to be returned as
-// a C string pointer that can be used.
+// Static function that puts a copy of the file system representation of
+// CF_STR into STR and returns the C string pointer that is contained in
+// STR when successful, else NULL is returned. This allows the std::string
+// parameter to own the extracted string, and also allows that string to
+// be returned as a C string pointer that can be used.
 
 const char *CFString::FileSystemRepresentation(CFStringRef cf_str,
                                                std::string &str) {
Index: source/Plugins/Process/Darwin/DarwinProcessLauncher.cpp
===================================================================
--- source/Plugins/Process/Darwin/DarwinProcessLauncher.cpp
+++ source/Plugins/Process/Darwin/DarwinProcessLauncher.cpp
@@ -130,8 +130,8 @@
   return false;
 }
 
-// TODO check if we have a general purpose fork and exec.  We may be
-// able to get rid of this entirely.
+// TODO check if we have a general purpose fork and exec.  We may be able
+// to get rid of this entirely.
 static Status ForkChildForPTraceDebugging(const char *path, char const *argv[],
                                           char const *envp[], ::pid_t *pid,
                                           int *pty_fd) {
@@ -142,8 +142,8 @@
   }
 
   // Use a fork that ties the child process's stdin/out/err to a pseudo
-  // terminal so we can read it in our MachProcess::STDIOThread
-  // as unbuffered io.
+  // terminal so we can read it in our MachProcess::STDIOThread as
+  // unbuffered io.
   PseudoTerminal pty;
   char fork_error[256];
   memset(fork_error, 0, sizeof(fork_error));
@@ -170,9 +170,9 @@
     // If our parent is setgid, lets make sure we don't inherit those
     // extra powers due to nepotism.
     if (::setgid(getgid()) == 0) {
-      // Let the child have its own process group. We need to execute
-      // this call in both the child and parent to avoid a race
-      // condition between the two processes.
+      // Let the child have its own process group. We need to execute this
+      // call in both the child and parent to avoid a race condition
+      // between the two processes.
 
       // Set the child process group to match its pid.
       ::setpgid(0, 0);
@@ -183,17 +183,17 @@
       // Turn this process into the given executable.
       ::execv(path, (char *const *)argv);
     }
-    // Exit with error code. Child process should have taken
-    // over in above exec call and if the exec fails it will
-    // exit the child process below.
+    // Exit with error code. Child process should have taken over in above
+    // exec call and if the exec fails it will exit the child process
+    // below.
     ::exit(127);
   } else {
     //--------------------------------------------------------------
     // Parent process
     //--------------------------------------------------------------
-    // Let the child have its own process group. We need to execute
-    // this call in both the child and parent to avoid a race condition
-    // between the two processes.
+    // Let the child have its own process group. We need to execute this
+    // call in both the child and parent to avoid a race condition between
+    // the two processes.
 
     // Set the child process group to match its pid
     ::setpgid(*pid, *pid);
@@ -376,8 +376,8 @@
 
   // We assume the caller has setup the file actions appropriately.  We
   // are not in the business of figuring out what we really need here.
-  // lldb-server will have already called FinalizeFileActions() as well
-  // to button these up properly.
+  // lldb-server will have already called FinalizeFileActions() as well to
+  // button these up properly.
   const size_t num_actions = launch_info.GetNumFileActions();
   for (size_t action_index = 0; action_index < num_actions; ++action_index) {
     const FileAction *const action =
@@ -465,12 +465,14 @@
     // Our default launch method is posix spawn
     *launch_flavor = LaunchFlavor::PosixSpawn;
 #if defined WITH_FBS
-    // Check if we have an app bundle, if so launch using BackBoard Services.
+    // Check if we have an app bundle, if so launch using BackBoard
+    // Services.
     if (strstr(given_path, ".app")) {
       *launch_flavor = eLaunchFlavorFBS;
     }
 #elif defined WITH_BKS
-    // Check if we have an app bundle, if so launch using BackBoard Services.
+    // Check if we have an app bundle, if so launch using BackBoard
+    // Services.
     if (strstr(given_path, ".app")) {
       *launch_flavor = eLaunchFlavorBKS;
     }
@@ -490,8 +492,8 @@
     log->Printf("%s(): attempting to resolve given binary path: \"%s\"",
                 __FUNCTION__, given_path);
 
-  // If we fail to resolve the path to our executable, then just use what we
-  // were given and hope for the best
+  // If we fail to resolve the path to our executable, then just use what
+  // we were given and hope for the best
   if (!ResolveExecutablePath(given_path, resolved_path,
                              sizeof(resolved_path))) {
     if (log)
@@ -508,8 +510,8 @@
   char launch_err_str[PATH_MAX];
   launch_err_str[0] = '\0';
 
-  // TODO figure out how to handle QSetProcessEvent
-  // const char *process_event = ctx.GetProcessEvent();
+  // TODO figure out how to handle QSetProcessEvent const char
+  // *process_event = ctx.GetProcessEvent();
 
   // Ensure the binary is there.
   struct stat path_stat;
Index: source/Plugins/Process/Darwin/MachException.cpp
===================================================================
--- source/Plugins/Process/Darwin/MachException.cpp
+++ source/Plugins/Process/Darwin/MachException.cpp
@@ -187,7 +187,8 @@
   mach_msg_timeout_t mach_msg_timeout =
       options & MACH_RCV_TIMEOUT ? timeout : 0;
   if (log && ((options & MACH_RCV_TIMEOUT) == 0)) {
-    // Dump this log message if we have no timeout in case it never returns
+    // Dump this log message if we have no timeout in case it never
+    // returns
     log->Printf("::mach_msg(msg->{bits = %#x, size = %u remote_port = %#x, "
                 "local_port = %#x, reserved = 0x%x, id = 0x%x}, "
                 "option = %#x, send_size = 0, rcv_size = %llu, "
@@ -249,18 +250,18 @@
   g_message = &state;
   // The exc_server function is the MIG generated server handling function
   // to handle messages from the kernel relating to the occurrence of an
-  // exception in a thread. Such messages are delivered to the exception port
-  // set via thread_set_exception_ports or task_set_exception_ports. When an
-  // exception occurs in a thread, the thread sends an exception message to
-  // its exception port, blocking in the kernel waiting for the receipt of a
-  // reply. The exc_server function performs all necessary argument handling
-  // for this kernel message and calls catch_exception_raise,
-  // catch_exception_raise_state or catch_exception_raise_state_identity,
-  // which should handle the exception. If the called routine returns
-  // KERN_SUCCESS, a reply message will be sent, allowing the thread to
-  // continue from the point of the exception; otherwise, no reply message
-  // is sent and the called routine must have dealt with the exception
-  // thread directly.
+  // exception in a thread. Such messages are delivered to the exception
+  // port set via thread_set_exception_ports or task_set_exception_ports.
+  // When an exception occurs in a thread, the thread sends an exception
+  // message to its exception port, blocking in the kernel waiting for the
+  // receipt of a reply. The exc_server function performs all necessary
+  // argument handling for this kernel message and calls
+  // catch_exception_raise, catch_exception_raise_state or
+  // catch_exception_raise_state_identity, which should handle the
+  // exception. If the called routine returns KERN_SUCCESS, a reply
+  // message will be sent, allowing the thread to continue from the point
+  // of the exception; otherwise, no reply message is sent and the called
+  // routine must have dealt with the exception thread directly.
   if (mach_exc_server(&exc_msg.hdr, &reply_msg.hdr)) {
     success = true;
   } else {
@@ -362,8 +363,8 @@
    EXC_MASK_SYSCALL | EXC_MASK_MACH_SYSCALL | EXC_MASK_RPC_ALERT |             \
    EXC_MASK_MACHINE)
 
-// Don't listen for EXC_RESOURCE, it should really get handled by the system
-// handler.
+// Don't listen for EXC_RESOURCE, it should really get handled by the
+// system handler.
 
 #ifndef EXC_RESOURCE
 #define EXC_RESOURCE 11
@@ -383,9 +384,10 @@
     log->Printf("MachException::PortInfo::%s(task = 0x%4.4x)", __FUNCTION__,
                 task);
 
-  // Be careful to be able to have debugserver built on a newer OS than what
-  // it is currently running on by being able to start with all exceptions
-  // and back off to just what is supported on the current system
+  // Be careful to be able to have debugserver built on a newer OS than
+  // what it is currently running on by being able to start with all
+  // exceptions and back off to just what is supported on the current
+  // system
   mask = LLDB_EXC_MASK;
 
   count = (sizeof(ports) / sizeof(ports[0]));
Index: source/Plugins/Process/Darwin/NativeProcessDarwin.cpp
===================================================================
--- source/Plugins/Process/Darwin/NativeProcessDarwin.cpp
+++ source/Plugins/Process/Darwin/NativeProcessDarwin.cpp
@@ -104,8 +104,8 @@
     return error;
   }
 
-  // Finalize the processing needed to debug the launched process with
-  // a NativeProcessDarwin instance.
+  // Finalize the processing needed to debug the launched process with a
+  // NativeProcessDarwin instance.
   error = np_darwin_sp->FinalizeLaunch(launch_flavor, mainloop);
   if (!error.Success()) {
     if (log)
@@ -115,7 +115,8 @@
     return error;
   }
 
-  // Return the process and process id to the caller through the launch args.
+  // Return the process and process id to the caller through the launch
+  // args.
   native_process_sp = np_darwin_sp;
   return error;
 }
@@ -243,9 +244,9 @@
   }
 
   if (TaskPortForProcessID(error) == TASK_NULL) {
-    // We failed to get the task for our process ID which is bad.
-    // Kill our process; otherwise, it will be stopped at the entry
-    // point and get reparented to someone else and never go away.
+    // We failed to get the task for our process ID which is bad. Kill our
+    // process; otherwise, it will be stopped at the entry point and get
+    // reparented to someone else and never go away.
     if (log)
       log->Printf("NativeProcessDarwin::%s(): could not get task port "
                   "for process, sending SIGKILL and exiting: %s",
@@ -278,8 +279,8 @@
 }
 
 // Called by the exception thread when an exception has been received from
-// our process. The exception message is completely filled and the exception
-// data has already been copied.
+// our process. The exception message is completely filled and the
+// exception data has already been copied.
 void NativeProcessDarwin::ExceptionMessageReceived(
     const MachException::Message &message) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_VERBOSE));
@@ -329,24 +330,24 @@
   // bunch of related exceptions on our exception port so we can process
   // then together. When we have multiple threads, we can get an exception
   // per thread and they will come in consecutively. The main loop in this
-  // thread can stop periodically if needed to service things related to this
-  // process.
+  // thread can stop periodically if needed to service things related to
+  // this process.
   //
   // [did we lose some words here?]
   //
   // flag set in the options, so we will wait forever for an exception on
-  // 0 our exception port. After we get one exception, we then will use the
-  // MACH_RCV_TIMEOUT option with a zero timeout to grab all other current
-  // exceptions for our process. After we have received the last pending
-  // exception, we will get a timeout which enables us to then notify
-  // our main thread that we have an exception bundle available. We then wait
-  // for the main thread to tell this exception thread to start trying to get
-  // exceptions messages again and we start again with a mach_msg read with
-  // infinite timeout.
+  // 0 our exception port. After we get one exception, we then will use
+  // the MACH_RCV_TIMEOUT option with a zero timeout to grab all other
+  // current exceptions for our process. After we have received the last
+  // pending exception, we will get a timeout which enables us to then
+  // notify our main thread that we have an exception bundle available. We
+  // then wait for the main thread to tell this exception thread to start
+  // trying to get exceptions messages again and we start again with a
+  // mach_msg read with infinite timeout.
   //
   // We choose to park a thread on this, rather than polling, because the
-  // polling is expensive.  On devices, we need to minimize overhead caused
-  // by the process monitor.
+  // polling is expensive.  On devices, we need to minimize overhead
+  // caused by the process monitor.
   uint32_t num_exceptions_received = 0;
   Status error;
   task_t task = m_task;
@@ -440,8 +441,8 @@
       if (error.GetError() == MACH_RCV_INTERRUPTED) {
         // We were interrupted.
 
-        // If we have no task port we should exit this thread, as it implies
-        // the inferior went down.
+        // If we have no task port we should exit this thread, as it
+        // implies the inferior went down.
         if (!IsExceptionPortValid()) {
           if (log)
             log->Printf("NativeProcessDarwin::%s(): the inferior "
@@ -462,8 +463,8 @@
                         __FUNCTION__);
           continue;
         } else {
-          // The inferior task is no longer valid.  Time to exit as
-          // the process has gone away.
+          // The inferior task is no longer valid.  Time to exit as the
+          // process has gone away.
           if (log)
             log->Printf("NativeProcessDarwin::%s(): the inferior task "
                         "has exited, and so will we...",
@@ -486,8 +487,8 @@
           // changed.
           task = ExceptionMessageBundleComplete();
 
-          // In case we use a timeout value when getting exceptions,
-          // make sure our task is still valid.
+          // In case we use a timeout value when getting exceptions, make
+          // sure our task is still valid.
           if (IsTaskValid(task)) {
             // Task is still ok.
             if (log)
@@ -496,8 +497,8 @@
                           __FUNCTION__);
             continue;
           } else {
-            // The inferior task is no longer valid.  Time to exit as
-            // the process has gone away.
+            // The inferior task is no longer valid.  Time to exit as the
+            // process has gone away.
             if (log)
               log->Printf("NativeProcessDarwin::%s(): the inferior "
                           "task has exited, and so will we...",
@@ -531,13 +532,11 @@
 
 #if defined(WITH_SPRINGBOARD) && !defined(WITH_BKS)
   if (watchdog.get()) {
-    // TODO: change SBSWatchdogAssertionRelease to SBSWatchdogAssertionCancel
-    // when we
-    // all are up and running on systems that support it. The SBS framework has
-    // a #define
-    // that will forward SBSWatchdogAssertionRelease to
-    // SBSWatchdogAssertionCancel for now
-    // so it should still build either way.
+    // TODO: change SBSWatchdogAssertionRelease to
+    // SBSWatchdogAssertionCancel when we all are up and running on
+    // systems that support it. The SBS framework has a #define that will
+    // forward SBSWatchdogAssertionRelease to SBSWatchdogAssertionCancel
+    // for now so it should still build either way.
     DNBLogThreadedIf(LOG_TASK, "::SBSWatchdogAssertionRelease(%p)",
                      watchdog.get());
     ::SBSWatchdogAssertionRelease(watchdog.get());
@@ -570,7 +569,8 @@
   // Get the mach port for the process monitor.
   mach_port_t task_self = mach_task_self();
 
-  // Allocate an exception port that we will use to track our child process
+  // Allocate an exception port that we will use to track our child
+  // process
   auto mach_err = ::mach_port_allocate(task_self, MACH_PORT_RIGHT_RECEIVE,
                                        &m_exception_port);
   error.SetError(mach_err, eErrorTypeMachKernel);
@@ -727,9 +727,9 @@
       ++num_task_exceptions;
       const int signo = m_exception_messages[i].state.SoftSignal();
       if (signo == SIGTRAP) {
-        // SIGTRAP could mean that we exec'ed. We need to check the
-        // dyld all_image_infos.infoArray to see if it is NULL and if
-        // so, say that we exec'ed.
+        // SIGTRAP could mean that we exec'ed. We need to check the dyld
+        // all_image_infos.infoArray to see if it is NULL and if so, say
+        // that we exec'ed.
         const addr_t aii_addr = GetDYLDAllImageInfosAddress(error);
         if (aii_addr == LLDB_INVALID_ADDRESS)
           break;
@@ -744,12 +744,12 @@
                                 bytes_read);           // #bytes read
         if (read_error.Success() && (bytes_read == 4)) {
           if (info_array_count == 0) {
-            // We got the all infos address, and there are zero
-            // entries.  We think we exec'd.
+            // We got the all infos address, and there are zero entries.
+            // We think we exec'd.
             m_did_exec = true;
 
-            // Force the task port to update itself in case the
-            // task port changed after exec
+            // Force the task port to update itself in case the task port
+            // changed after exec
             const task_t old_task = m_task;
             const bool force_update = true;
             const task_t new_task = TaskPortForProcessID(error, force_update);
@@ -831,8 +831,8 @@
     }
   }
 
-  // Let all threads recover from stopping and do any clean up based
-  // on the previous thread state (if any).
+  // Let all threads recover from stopping and do any clean up based on
+  // the previous thread state (if any).
   m_thread_list.ProcessDidStop(*this);
 
   // Let each thread know of any exceptions
@@ -890,11 +890,11 @@
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   // Strategy: create a thread that sits on waitpid(), waiting for the
-  // inferior process to die, reaping it in the process.  Arrange for
-  // the thread to have a pipe file descriptor that it can send a byte
-  // over when the waitpid completes.  Have the main loop have a read
-  // object for the other side of the pipe, and have the callback for
-  // the read do the process termination message sending.
+  // inferior process to die, reaping it in the process.  Arrange for the
+  // thread to have a pipe file descriptor that it can send a byte over
+  // when the waitpid completes.  Have the main loop have a read object
+  // for the other side of the pipe, and have the callback for the read do
+  // the process termination message sending.
 
   // Create a single-direction communication channel.
   const bool child_inherits = false;
@@ -1026,7 +1026,8 @@
   }
 
   // We should never exit as long as our child process is alive.  If we
-  // get here, something completely unexpected went wrong and we should exit.
+  // get here, something completely unexpected went wrong and we should
+  // exit.
   if (log)
     log->Printf(
         "NativeProcessDarwin::%s(): internal error: waitpid thread "
@@ -1157,8 +1158,8 @@
       ::usleep(usec_interval);
     }
 
-    // We failed to get the task for the inferior process.
-    // Ensure that it is cleared out.
+    // We failed to get the task for the inferior process. Ensure that it
+    // is cleared out.
     m_task = TASK_NULL;
   }
   return m_task;
@@ -1197,8 +1198,8 @@
   //    bool stepOverBreakInstruction = step;
 
   // Let the thread prepare to resume and see if any threads want us to
-  // step over a breakpoint instruction (ProcessWillResume will modify
-  // the value of stepOverBreakInstruction).
+  // step over a breakpoint instruction (ProcessWillResume will modify the
+  // value of stepOverBreakInstruction).
   m_thread_list.ProcessWillResume(*this, m_thread_actions);
 
   // Set our state accordingly
@@ -1254,8 +1255,8 @@
 
     error = message.Reply(m_pid, m_task, thread_reply_signal);
     if (error.Fail() && log) {
-      // We log any error here, but we don't stop the exception
-      // response handling.
+      // We log any error here, but we don't stop the exception response
+      // handling.
       log->Printf("NativeProcessDarwin::%s(): failed to reply to "
                   "exception: %s",
                   __FUNCTION__, error.AsCString());
@@ -1263,8 +1264,8 @@
     }
   }
 
-  // Erase all exception message as we should have used and replied
-  // to them all already.
+  // Erase all exception message as we should have used and replied to
+  // them all already.
   m_exception_messages.clear();
   return error;
 }
@@ -1304,9 +1305,8 @@
     return error;
   }
 
-  // task_resume isn't counted like task_suspend calls are, so if the
-  // task is not suspended, don't try and resume it since it is already
-  // running
+  // task_resume isn't counted like task_suspend calls are, so if the task
+  // is not suspended, don't try and resume it since it is already running
   if (task_info.suspend_count > 0) {
     auto mach_err = ::task_resume(m_task);
     error.SetError(mach_err, eErrorTypeMachKernel);
Index: source/Plugins/Process/Darwin/NativeThreadDarwin.cpp
===================================================================
--- source/Plugins/Process/Darwin/NativeThreadDarwin.cpp
+++ source/Plugins/Process/Darwin/NativeThreadDarwin.cpp
@@ -30,8 +30,8 @@
                                 (thread_info_t)&tident, &tident_count);
   if (mach_err != KERN_SUCCESS) {
     // When we fail to get thread info for the supposed port, assume it is
-    // really a globally unique thread id already, or return the best thing
-    // we can, which is the thread port.
+    // really a globally unique thread id already, or return the best
+    // thing we can, which is the thread port.
     return mach_port_id;
   }
   return tident.thread_id;
@@ -46,10 +46,10 @@
       m_proc_threadinfo() {}
 
 bool NativeThreadDarwin::GetIdentifierInfo() {
-  // Don't try to get the thread info once and cache it for the life of the
-  // thread.  It changes over time, for instance
-  // if the thread name changes, then the thread_handle also changes...  So you
-  // have to refetch it every time.
+  // Don't try to get the thread info once and cache it for the life of
+  // the thread.  It changes over time, for instance if the thread name
+  // changes, then the thread_handle also changes...  So you have to
+  // refetch it every time.
   mach_msg_type_number_t count = THREAD_IDENTIFIER_INFO_COUNT;
   kern_return_t kret = ::thread_info(m_mach_thread_port, THREAD_IDENTIFIER_INFO,
                                      (thread_info_t)&m_ident_info, &count);
@@ -136,17 +136,17 @@
 bool NativeThreadDarwin::NotifyException(MachException::Data &exc) {
 // TODO implement this.
 #if 0
-    // Allow the arch specific protocol to process (MachException::Data &)exc
-    // first before possible reassignment of m_stop_exception with exc.
-    // See also MachThread::GetStopException().
+    // Allow the arch specific protocol to process (MachException::Data
+    // &)exc first before possible reassignment of m_stop_exception with
+    // exc. See also MachThread::GetStopException().
     bool handled = m_arch_ap->NotifyException(exc);
 
     if (m_stop_exception.IsValid())
     {
-        // We may have more than one exception for a thread, but we need to
-        // only remember the one that we will say is the reason we stopped.
-        // We may have been single stepping and also gotten a signal exception,
-        // so just remember the most pertinent one.
+        // We may have more than one exception for a thread, but we need
+        // to only remember the one that we will say is the reason we
+        // stopped. We may have been single stepping and also gotten a
+        // signal exception, so just remember the most pertinent one.
         if (m_stop_exception.IsBreakpoint())
             m_stop_exception = exc;
     }
@@ -170,8 +170,8 @@
 
     if (bp)
     {
-        // This thread is sitting at a breakpoint, ask the breakpoint
-        // if we should be stopping here.
+        // This thread is sitting at a breakpoint, ask the breakpoint if
+        // we should be stopping here.
         return true;
     }
     else
@@ -183,13 +183,12 @@
         }
         // The thread state is used to let us know what the thread was
         // trying to do. MachThread::ThreadWillResume() will set the
-        // thread state to various values depending if the thread was
-        // the current thread and if it was to be single stepped, or
-        // resumed.
+        // thread state to various values depending if the thread was the
+        // current thread and if it was to be single stepped, or resumed.
         if (GetState() == eStateRunning)
         {
-            // If our state is running, then we should continue as we are in
-            // the process of stepping over a breakpoint.
+            // If our state is running, then we should continue as we are
+            // in the process of stepping over a breakpoint.
             return false;
         }
         else
@@ -213,10 +212,10 @@
     // and has just been stopped. Do any cleanup that needs to be done
     // after running.
 
-    // The thread state and breakpoint will still have the same values
-    // as they had prior to resuming the thread, so it makes it easy to check
-    // if we were trying to step a thread, or we tried to resume while being
-    // at a breakpoint.
+    // The thread state and breakpoint will still have the same values as
+    // they had prior to resuming the thread, so it makes it easy to check
+    // if we were trying to step a thread, or we tried to resume while
+    // being at a breakpoint.
 
     // When this method gets called, the process state is still in the
     // state it was in while running so we can act accordingly.
Index: source/Plugins/Process/Darwin/NativeThreadListDarwin.cpp
===================================================================
--- source/Plugins/Process/Darwin/NativeThreadListDarwin.cpp
+++ source/Plugins/Process/Darwin/NativeThreadListDarwin.cpp
@@ -358,9 +358,9 @@
     if (thread_list_count > 0) {
       collection currThreads;
       size_t idx;
-      // Iterator through the current thread list and see which threads
-      // we already have in our list (keep them), which ones we don't
-      // (add them), and which ones are not around anymore (remove them).
+      // Iterator through the current thread list and see which threads we
+      // already have in our list (keep them), which ones we don't (add
+      // them), and which ones are not around anymore (remove them).
       for (idx = 0; idx < thread_list_count; ++idx) {
         // Get the Mach thread port.
         const ::thread_t mach_port_num = thread_list[idx];
@@ -373,8 +373,8 @@
         // Retrieve the thread if it exists.
         auto thread_sp = GetThreadByID(unique_thread_id);
         if (thread_sp) {
-          // We are already tracking it. Keep the existing native
-          // thread instance.
+          // We are already tracking it. Keep the existing native thread
+          // instance.
           currThreads.push_back(thread_sp);
         } else {
           // We don't have a native thread instance for this thread.
@@ -383,8 +383,8 @@
               &process, m_is_64_bit, unique_thread_id, mach_port_num));
 
           // Add the new thread regardless of its is user ready state.
-          // Make sure the thread is ready to be displayed and shown
-          // to users before we add this thread to our list...
+          // Make sure the thread is ready to be displayed and shown to
+          // users before we add this thread to our list...
           if (thread_sp->IsUserReady()) {
             if (new_threads)
               new_threads->push_back(thread_sp);
@@ -417,9 +417,9 @@
     PTHREAD_MUTEX_LOCKER (locker, m_threads_mutex);
     if (m_current_thread.get() == NULL)
     {
-        // Figure out which thread is going to be our current thread.
-        // This is currently done by finding the first thread in the list
-        // that has a valid exception.
+        // Figure out which thread is going to be our current thread. This
+        // is currently done by finding the first thread in the list that
+        // has a valid exception.
         const size_t num_threads = m_threads.size();
         for (uint32_t idx = 0; idx < num_threads; ++idx)
         {
@@ -461,8 +461,8 @@
 
 // TODO implement this.
 #if 0
-    // First figure out if we were planning on running only one thread, and if
-    // so, force that thread to resume.
+    // First figure out if we were planning on running only one thread,
+    // and if so, force that thread to resume.
     bool run_one_thread;
     thread_t solo_thread = THREAD_NULL;
     if ((thread_actions.GetSize() > 0) &&
@@ -489,7 +489,8 @@
 
 #if 0
     DNBThreadResumeAction resume_new_threads = { -1U, eStateRunning, 0, INVALID_NUB_ADDRESS };
-    // If we are planning to run only one thread, any new threads should be suspended.
+    // If we are planning to run only one thread, any new threads should
+    // be suspended.
     if (run_one_thread)
         resume_new_threads.state = eStateSuspended;
 
@@ -552,8 +553,8 @@
 // Check each thread in our thread list to see if we should notify our
 // client of the current halt in execution.
 //
-// Breakpoints can have callback functions associated with them than
-// can return true to stop, or false to continue executing the inferior.
+// Breakpoints can have callback functions associated with them than can
+// return true to stop, or false to continue executing the inferior.
 //
 // RETURNS
 //    true if we should stop and notify our clients
@@ -607,8 +608,9 @@
     return false;
 }
 
-// DNBWatchpointSet() -> MachProcess::CreateWatchpoint() -> MachProcess::EnableWatchpoint()
-// -> NativeThreadListDarwin::EnableHardwareWatchpoint().
+// DNBWatchpointSet() -> MachProcess::CreateWatchpoint() ->
+// MachProcess::EnableWatchpoint() ->
+// NativeThreadListDarwin::EnableHardwareWatchpoint().
 uint32_t
 NativeThreadListDarwin::EnableHardwareWatchpoint (const DNBBreakpoint* wp) const
 {
@@ -617,14 +619,16 @@
     {
         PTHREAD_MUTEX_LOCKER (locker, m_threads_mutex);
         const size_t num_threads = m_threads.size();
-        // On Mac OS X we have to prime the control registers for new threads.  We do this
-        // using the control register data for the first thread, for lack of a better way of choosing.
+        // On Mac OS X we have to prime the control registers for new
+        // threads.  We do this using the control register data for the
+        // first thread, for lack of a better way of choosing.
         bool also_set_on_task = true;
         for (uint32_t idx = 0; idx < num_threads; ++idx)
         {                
             if ((hw_index = m_threads[idx]->EnableHardwareWatchpoint(wp, also_set_on_task)) == INVALID_NUB_HW_INDEX)
             {
-                // We know that idx failed for some reason.  Let's rollback the transaction for [0, idx).
+                // We know that idx failed for some reason.  Let's
+                // rollback the transaction for [0, idx).
                 for (uint32_t i = 0; i < idx; ++i)
                     m_threads[i]->RollbackTransForHWP();
                 return INVALID_NUB_HW_INDEX;
@@ -647,14 +651,16 @@
         PTHREAD_MUTEX_LOCKER (locker, m_threads_mutex);
         const size_t num_threads = m_threads.size();
         
-        // On Mac OS X we have to prime the control registers for new threads.  We do this
-        // using the control register data for the first thread, for lack of a better way of choosing.
+        // On Mac OS X we have to prime the control registers for new
+        // threads.  We do this using the control register data for the
+        // first thread, for lack of a better way of choosing.
         bool also_set_on_task = true;
         for (uint32_t idx = 0; idx < num_threads; ++idx)
         {
             if (!m_threads[idx]->DisableHardwareWatchpoint(wp, also_set_on_task))
             {
-                // We know that idx failed for some reason.  Let's rollback the transaction for [0, idx).
+                // We know that idx failed for some reason.  Let's
+                // rollback the transaction for [0, idx).
                 for (uint32_t i = 0; i < idx; ++i)
                     m_threads[i]->RollbackTransForHWP();
                 return false;
@@ -675,7 +681,8 @@
 {
     PTHREAD_MUTEX_LOCKER (locker, m_threads_mutex);
     const size_t num_threads = m_threads.size();
-    // Use an arbitrary thread to retrieve the number of supported hardware watchpoints.
+    // Use an arbitrary thread to retrieve the number of supported
+    // hardware watchpoints.
     if (num_threads)
         return m_threads[0]->NumSupportedHardwareWatchpoints();
     return 0;
Index: source/Plugins/Process/FreeBSD/FreeBSDThread.cpp
===================================================================
--- source/Plugins/Process/FreeBSD/FreeBSDThread.cpp
+++ source/Plugins/Process/FreeBSD/FreeBSDThread.cpp
@@ -69,15 +69,15 @@
   for (uint32_t wp_idx = 0; wp_idx < wp_size; wp_idx++) {
     lldb::WatchpointSP wp = wp_list.GetByIndex(wp_idx);
     if (wp.get() && wp->IsEnabled()) {
-      // This watchpoint as been enabled; obviously this "new" thread
-      // has been created since that watchpoint was enabled.  Since
-      // the POSIXBreakpointProtocol has yet to be initialized, its
+      // This watchpoint as been enabled; obviously this "new" thread has
+      // been created since that watchpoint was enabled.  Since the
+      // POSIXBreakpointProtocol has yet to be initialized, its
       // m_watchpoints_initialized member will be FALSE.  Attempting to
-      // read the debug status register to determine if a watchpoint
-      // has been hit would result in the zeroing of that register.
-      // Since the active debug registers would have been cloned when
-      // this thread was created, simply force the m_watchpoints_initized
-      // member to TRUE and avoid resetting dr6 and dr7.
+      // read the debug status register to determine if a watchpoint has
+      // been hit would result in the zeroing of that register. Since the
+      // active debug registers would have been cloned when this thread
+      // was created, simply force the m_watchpoints_initized member to
+      // TRUE and avoid resetting dr6 and dr7.
       GetPOSIXBreakpointProtocol()->ForceWatchpointsInitialized();
     }
   }
@@ -92,15 +92,15 @@
 }
 
 void FreeBSDThread::RefreshStateAfterStop() {
-  // Invalidate all registers in our register context. We don't set "force" to
-  // true because the stop reply packet might have had some register values
-  // that were expedited and these will already be copied into the register
-  // context by the time this function gets called. The KDPRegisterContext
-  // class has been made smart enough to detect when it needs to invalidate
-  // which registers are valid by putting hooks in the register read and
-  // register supply functions where they check the process stop ID and do
-  // the right thing.
-  // if (StateIsStoppedState(GetState())
+  // Invalidate all registers in our register context. We don't set
+  // "force" to true because the stop reply packet might have had some
+  // register values that were expedited and these will already be copied
+  // into the register context by the time this function gets called. The
+  // KDPRegisterContext class has been made smart enough to detect when it
+  // needs to invalidate which registers are valid by putting hooks in the
+  // register read and register supply functions where they check the
+  // process stop ID and do the right thing. if
+  // (StateIsStoppedState(GetState())
   {
     const bool force = false;
     GetRegisterContext()->InvalidateIfNeeded(force);
@@ -468,20 +468,17 @@
   lldb::BreakpointSiteSP bp_site(
       GetProcess()->GetBreakpointSiteList().FindByAddress(pc));
 
-  // If the breakpoint is for this thread, then we'll report the hit, but if it
-  // is for another thread,
-  // we create a stop reason with should_stop=false.  If there is no breakpoint
-  // location, then report
-  // an invalid stop reason. We don't need to worry about stepping over the
-  // breakpoint here, that will
-  // be taken care of when the thread resumes and notices that there's a
-  // breakpoint under the pc.
+  // If the breakpoint is for this thread, then we'll report the hit, but
+  // if it is for another thread, we create a stop reason with
+  // should_stop=false.  If there is no breakpoint location, then report
+  // an invalid stop reason. We don't need to worry about stepping over
+  // the breakpoint here, that will be taken care of when the thread
+  // resumes and notices that there's a breakpoint under the pc.
   if (bp_site) {
     lldb::break_id_t bp_id = bp_site->GetID();
     // If we have an operating system plug-in, we might have set a thread
-    // specific breakpoint using the
-    // operating system thread ID, so we can't make any assumptions about the
-    // thread ID so we must always
+    // specific breakpoint using the operating system thread ID, so we
+    // can't make any assumptions about the thread ID so we must always
     // report the breakpoint regardless of the thread.
     if (bp_site->ValidForThisThread(this) ||
         GetProcess()->GetOperatingSystem() != NULL)
@@ -541,13 +538,12 @@
   lldb::BreakpointSiteSP bp_site(
       GetProcess()->GetBreakpointSiteList().FindByAddress(pc));
 
-  // If the current pc is a breakpoint site then set the StopInfo to Breakpoint.
-  // Otherwise, set the StopInfo to Watchpoint or Trace.
-  // If we have an operating system plug-in, we might have set a thread specific
-  // breakpoint using the
-  // operating system thread ID, so we can't make any assumptions about the
-  // thread ID so we must always
-  // report the breakpoint regardless of the thread.
+  // If the current pc is a breakpoint site then set the StopInfo to
+  // Breakpoint. Otherwise, set the StopInfo to Watchpoint or Trace. If we
+  // have an operating system plug-in, we might have set a thread specific
+  // breakpoint using the operating system thread ID, so we can't make any
+  // assumptions about the thread ID so we must always report the
+  // breakpoint regardless of the thread.
   if (bp_site && (bp_site->ValidForThisThread(this) ||
                   GetProcess()->GetOperatingSystem() != NULL))
     SetStopInfo(StopInfo::CreateStopReasonWithBreakpointSiteID(
Index: source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp
===================================================================
--- source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp
+++ source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp
@@ -359,8 +359,8 @@
     file_spec = file_action->GetFileSpec();
     // By default the stdio paths passed in will be pseudo-terminal
     // (/dev/pts). If so, convert to using a different default path
-    // instead to redirect I/O to the debugger console. This should
-    // also handle user overrides to /dev/null or a different file.
+    // instead to redirect I/O to the debugger console. This should also
+    // handle user overrides to /dev/null or a different file.
     if (!file_spec || file_spec == dbg_pts_file_spec)
       file_spec = default_file_spec;
   }
@@ -417,8 +417,8 @@
 
   int terminal = m_monitor->GetTerminalFD();
   if (terminal >= 0) {
-// The reader thread will close the file descriptor when done, so we pass it a
-// copy.
+// The reader thread will close the file descriptor when done, so we pass
+// it a copy.
 #ifdef F_DUPFD_CLOEXEC
     int stdio = fcntl(terminal, F_DUPFD_CLOEXEC, 0);
     if (stdio == -1) {
@@ -550,9 +550,9 @@
 
   std::lock_guard<std::recursive_mutex> guard(m_message_mutex);
 
-  // This method used to only handle one message.  Changing it to loop allows
-  // it to handle the case where we hit a breakpoint while handling a different
-  // breakpoint.
+  // This method used to only handle one message.  Changing it to loop
+  // allows it to handle the case where we hit a breakpoint while handling
+  // a different breakpoint.
   while (!m_message_queue.empty()) {
     ProcessMessage &message = m_message_queue.front();
 
@@ -569,8 +569,8 @@
       thread->Notify(message);
 
     if (message.GetKind() == ProcessMessage::eExitMessage) {
-      // FIXME: We should tell the user about this, but the limbo message is
-      // probably better for that.
+      // FIXME: We should tell the user about this, but the limbo message
+      // is probably better for that.
       LLDB_LOG(log, "removing thread, tid = {0}", tid);
       std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
 
@@ -655,8 +655,8 @@
     break;
 
   case llvm::Triple::arm: {
-    // The ARM reference recommends the use of 0xe7fddefe and 0xdefe
-    // but the linux kernel does otherwise.
+    // The ARM reference recommends the use of 0xe7fddefe and 0xdefe but
+    // the linux kernel does otherwise.
     static const uint8_t g_arm_breakpoint_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
     static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};
 
@@ -744,8 +744,8 @@
         wp->SetEnabled(true, notify);
         return error;
       } else {
-        // Watchpoint enabling failed on at least one
-        // of the threads so roll back all of them
+        // Watchpoint enabling failed on at least one of the threads so
+        // roll back all of them
         DisableWatchpoint(wp, false);
         error.SetErrorString("Setting hardware watchpoint failed");
       }
@@ -812,8 +812,8 @@
 
 Status ProcessFreeBSD::GetWatchpointSupportInfo(uint32_t &num, bool &after) {
   Status error = GetWatchpointSupportInfo(num);
-  // Watchpoints trigger and halt the inferior after
-  // the corresponding instruction has been executed.
+  // Watchpoints trigger and halt the inferior after the corresponding
+  // instruction has been executed.
   after = true;
   return error;
 }
@@ -825,8 +825,8 @@
 }
 
 ByteOrder ProcessFreeBSD::GetByteOrder() const {
-  // FIXME: We should be able to extract this value directly.  See comment in
-  // ProcessFreeBSD().
+  // FIXME: We should be able to extract this value directly.  See comment
+  // in ProcessFreeBSD().
   return m_byte_order;
 }
 
@@ -938,9 +938,9 @@
     return true;
   }
 
-  // The emulator only fills in the dwarf register numbers (and in some cases
-  // the generic register numbers). Get the full register info from the
-  // register context based on the dwarf register numbers.
+  // The emulator only fills in the dwarf register numbers (and in some
+  // cases the generic register numbers). Get the full register info from
+  // the register context based on the dwarf register numbers.
   const RegisterInfo *full_reg_info =
       emulator_baton->m_reg_context->GetRegisterInfo(
           eRegisterKindDWARF, reg_info->kinds[eRegisterKindDWARF]);
@@ -1077,15 +1077,15 @@
     next_pc = pc_it->second.GetAsUInt64();
   } else if (pc_it == baton.m_register_values.end()) {
     // Emulate instruction failed and it haven't changed PC. Advance PC
-    // with the size of the current opcode because the emulation of all
-    // PC modifying instruction should be successful. The failure most
-    // likely caused by a not supported instruction which don't modify PC.
+    // with the size of the current opcode because the emulation of all PC
+    // modifying instruction should be successful. The failure most likely
+    // caused by a not supported instruction which don't modify PC.
     next_pc =
         register_context_sp->GetPC() + emulator_ap->GetOpcode().GetByteSize();
   } else {
     // The instruction emulation failed after it modified the PC. It is an
-    // unknown error where we can't continue because the next instruction is
-    // modifying the PC but we don't  know how.
+    // unknown error where we can't continue because the next instruction
+    // is modifying the PC but we don't  know how.
     return Status("Instruction emulation failed unexpectedly");
   }
 
Index: source/Plugins/Process/FreeBSD/ProcessMonitor.cpp
===================================================================
--- source/Plugins/Process/FreeBSD/ProcessMonitor.cpp
+++ source/Plugins/Process/FreeBSD/ProcessMonitor.cpp
@@ -41,8 +41,8 @@
 using namespace lldb;
 using namespace lldb_private;
 
-// We disable the tracing of ptrace calls for integration builds to
-// avoid the additional indirection and checks.
+// We disable the tracing of ptrace calls for integration builds to avoid
+// the additional indirection and checks.
 #ifndef LLDB_CONFIGURATION_BUILDANDINTEGRATION
 // Wrapper for ptrace to catch errors and log calls.
 
@@ -61,9 +61,8 @@
   }
 }
 
-// Wrapper for ptrace to catch errors and log calls.
-// Note that ptrace sets errno on error because -1 is reserved as a valid
-// result.
+// Wrapper for ptrace to catch errors and log calls. Note that ptrace sets
+// errno on error because -1 is reserved as a valid result.
 extern long PtraceWrapper(int req, lldb::pid_t pid, void *addr, int data,
                           const char *reqName, const char *file, int line) {
   long int result;
@@ -130,8 +129,8 @@
   return result;
 }
 
-// Wrapper for ptrace when logging is not required.
-// Sets errno to 0 prior to calling ptrace.
+// Wrapper for ptrace when logging is not required. Sets errno to 0 prior
+// to calling ptrace.
 extern long PtraceWrapper(int req, lldb::pid_t pid, void *addr, int data) {
   long result = 0;
   errno = 0;
@@ -147,8 +146,8 @@
 
 //------------------------------------------------------------------------------
 // Static implementations of ProcessMonitor::ReadMemory and
-// ProcessMonitor::WriteMemory.  This enables mutual recursion between these
-// functions without needed to go thru the thread funnel.
+// ProcessMonitor::WriteMemory.  This enables mutual recursion between
+// these functions without needed to go thru the thread funnel.
 
 static size_t DoReadMemory(lldb::pid_t pid, lldb::addr_t vm_addr, void *buf,
                            size_t size, Status &error) {
@@ -297,8 +296,8 @@
     m_result = false;
   } else {
     // 'struct reg' contains only 32- or 64-bit register values.  Punt on
-    // others.  Also, not all entries may be uintptr_t sized, such as 32-bit
-    // processes on powerpc64 (probably the same for i386 on amd64)
+    // others.  Also, not all entries may be uintptr_t sized, such as
+    // 32-bit processes on powerpc64 (probably the same for i386 on amd64)
     if (m_size == sizeof(uint32_t))
       m_value = *(uint32_t *)(((caddr_t)&regs) + m_offset);
     else if (m_size == sizeof(uint64_t))
@@ -953,8 +952,8 @@
          "Could not sync with inferior process.");
 
 #ifdef notyet
-  // Have the child raise an event on exit.  This is used to keep the child in
-  // limbo until it is destroyed.
+  // Have the child raise an event on exit.  This is used to keep the
+  // child in limbo until it is destroyed.
   if (PTRACE(PTRACE_SETOPTIONS, pid, NULL, PTRACE_O_TRACEEXIT) < 0) {
     args->m_error.SetErrorToErrno();
     goto FINISH;
@@ -1119,7 +1118,8 @@
   case 0:
   case TRAP_TRACE:
 #ifdef TRAP_CAP
-  // Map TRAP_CAP to a trace trap in the absense of a more specific handler.
+  // Map TRAP_CAP to a trace trap in the absense of a more specific
+  // handler.
   case TRAP_CAP:
 #endif
     if (log)
@@ -1158,9 +1158,9 @@
 
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 
-  // POSIX says that process behaviour is undefined after it ignores a SIGFPE,
-  // SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated by a
-  // kill(2) or raise(3).  Similarly for tgkill(2) on FreeBSD.
+  // POSIX says that process behaviour is undefined after it ignores a
+  // SIGFPE, SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated
+  // by a kill(2) or raise(3).  Similarly for tgkill(2) on FreeBSD.
   //
   // IOW, user generated signals never generate what we consider to be a
   // "crash".
@@ -1196,8 +1196,8 @@
     } // else; Use atleast si_signo info for other si_code
   }
 
-  // Everything else is "normal" and does not require any special action on
-  // our part.
+  // Everything else is "normal" and does not require any special action
+  // on our part.
   return ProcessMessage::Signal(tid, signo);
 }
 
@@ -1422,22 +1422,24 @@
   }
 }
 
-// FIXME: On Linux, when a new thread is created, we receive to notifications,
-// (1) a SIGTRAP|PTRACE_EVENT_CLONE from the main process thread with the
-// child thread id as additional information, and (2) a SIGSTOP|SI_USER from
-// the new child thread indicating that it has is stopped because we attached.
-// We have no guarantee of the order in which these arrive, but we need both
-// before we are ready to proceed.  We currently keep a list of threads which
-// have sent the initial SIGSTOP|SI_USER event.  Then when we receive the
-// SIGTRAP|PTRACE_EVENT_CLONE notification, if the initial stop has not occurred
-// we call ProcessMonitor::WaitForInitialTIDStop() to wait for it.
+// FIXME: On Linux, when a new thread is created, we receive to
+// notifications, (1) a SIGTRAP|PTRACE_EVENT_CLONE from the main process
+// thread with the child thread id as additional information, and (2) a
+// SIGSTOP|SI_USER from the new child thread indicating that it has is
+// stopped because we attached. We have no guarantee of the order in which
+// these arrive, but we need both before we are ready to proceed.  We
+// currently keep a list of threads which have sent the initial
+// SIGSTOP|SI_USER event.  Then when we receive the
+// SIGTRAP|PTRACE_EVENT_CLONE notification, if the initial stop has not
+// occurred we call ProcessMonitor::WaitForInitialTIDStop() to wait for
+// it.
 //
-// Right now, the above logic is in ProcessPOSIX, so we need a definition of
-// this function in the FreeBSD ProcessMonitor implementation even if it isn't
-// logically needed.
+// Right now, the above logic is in ProcessPOSIX, so we need a definition
+// of this function in the FreeBSD ProcessMonitor implementation even if
+// it isn't logically needed.
 //
-// We really should figure out what actually happens on FreeBSD and move the
-// Linux-specific logic out of ProcessPOSIX as needed.
+// We really should figure out what actually happens on FreeBSD and move
+// the Linux-specific logic out of ProcessPOSIX as needed.
 
 bool ProcessMonitor::WaitForInitialTIDStop(lldb::tid_t tid) { return true; }
 
Index: source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_mips64.cpp
===================================================================
--- source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_mips64.cpp
+++ source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_mips64.cpp
@@ -130,14 +130,14 @@
     bool success = ReadRegister(full_reg, value);
 
     if (success) {
-      // If our read was not aligned (for ah,bh,ch,dh), shift our returned value
-      // one byte to the right.
+      // If our read was not aligned (for ah,bh,ch,dh), shift our returned
+      // value one byte to the right.
       if (is_subreg && (reg_info->byte_offset & 0x1))
         value.SetUInt64(value.GetAsUInt64() >> 8);
 
-      // If our return byte size was greater than the return value reg size,
-      // then
-      // use the type specified by reg_info rather than the uint64_t default
+      // If our return byte size was greater than the return value reg
+      // size, then use the type specified by reg_info rather than the
+      // uint64_t default
       if (value.GetByteSize() > reg_info->byte_size)
         value.SetType(reg_info);
     }
Index: source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_powerpc.cpp
===================================================================
--- source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_powerpc.cpp
+++ source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_powerpc.cpp
@@ -114,9 +114,9 @@
   }
 
   ProcessMonitor &monitor = GetMonitor();
-  // Account for the fact that 32-bit targets on powerpc64 really use 64-bit
-  // registers in ptrace, but expose here 32-bit registers with a higher
-  // offset.
+  // Account for the fact that 32-bit targets on powerpc64 really use
+  // 64-bit registers in ptrace, but expose here 32-bit registers with a
+  // higher offset.
   uint64_t offset = GetRegisterOffset(reg_to_write);
   offset &= ~(sizeof(uintptr_t) - 1);
   return monitor.WriteRegisterValue(
@@ -139,9 +139,9 @@
     bool success = ReadRegister(reg, value);
 
     if (success) {
-      // If our return byte size was greater than the return value reg size,
-      // then
-      // use the type specified by reg_info rather than the uint64_t default
+      // If our return byte size was greater than the return value reg
+      // size, then use the type specified by reg_info rather than the
+      // uint64_t default
       if (value.GetByteSize() > reg_info->byte_size)
         value.SetType(reg_info);
     }
Index: source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_x86.cpp
===================================================================
--- source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_x86.cpp
+++ source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_x86.cpp
@@ -18,7 +18,8 @@
 using namespace lldb_private;
 using namespace lldb;
 
-// Support ptrace extensions even when compiled without required kernel support
+// Support ptrace extensions even when compiled without required kernel
+// support
 #ifndef NT_X86_XSTATE
 #define NT_X86_XSTATE 0x202
 #endif
@@ -55,7 +56,8 @@
         Thread &thread, uint32_t concrete_frame_idx,
         lldb_private::RegisterInfoInterface *register_info)
     : RegisterContextPOSIX_x86(thread, concrete_frame_idx, register_info) {
-  // Store byte offset of fctrl (i.e. first register of FPR) wrt 'UserArea'
+  // Store byte offset of fctrl (i.e. first register of FPR) wrt
+  // 'UserArea'
   const RegisterInfo *reg_info_fctrl = GetRegisterInfoByName("fctrl");
   m_fctrl_offset_in_userarea = reg_info_fctrl->byte_offset;
 
@@ -193,14 +195,14 @@
     bool success = ReadRegister(full_reg, value);
 
     if (success) {
-      // If our read was not aligned (for ah,bh,ch,dh), shift our returned value
-      // one byte to the right.
+      // If our read was not aligned (for ah,bh,ch,dh), shift our returned
+      // value one byte to the right.
       if (is_subreg && (reg_info->byte_offset & 0x1))
         value.SetUInt64(value.GetAsUInt64() >> 8);
 
-      // If our return byte size was greater than the return value reg size,
-      // then
-      // use the type specified by reg_info rather than the uint64_t default
+      // If our return byte size was greater than the return value reg
+      // size, then use the type specified by reg_info rather than the
+      // uint64_t default
       if (value.GetByteSize() > reg_info->byte_size)
         value.SetType(reg_info);
     }
@@ -221,7 +223,8 @@
         value.SetBytes(m_fpr.fxsave.xmm[reg - m_reg_info.first_xmm].bytes,
                        reg_info->byte_size, byte_order);
       if (reg >= m_reg_info.first_ymm && reg <= m_reg_info.last_ymm) {
-        // Concatenate ymm using the register halves in xmm.bytes and ymmh.bytes
+        // Concatenate ymm using the register halves in xmm.bytes and
+        // ymmh.bytes
         if (GetFPRType() == eXSAVE && CopyXSTATEtoYMM(reg, byte_order))
           value.SetBytes(m_ymm_set.ymm[reg - m_reg_info.first_ymm].bytes,
                          reg_info->byte_size, byte_order);
@@ -233,13 +236,12 @@
     return false;
   }
 
-  // Get pointer to m_fpr.fxsave variable and set the data from it.
-  // Byte offsets of all registers are calculated wrt 'UserArea' structure.
-  // However, ReadFPR() reads fpu registers {using ptrace(PT_GETFPREGS,..)}
-  // and stores them in 'm_fpr' (of type FPR structure). To extract values of
-  // fpu
-  // registers, m_fpr should be read at byte offsets calculated wrt to FPR
-  // structure.
+  // Get pointer to m_fpr.fxsave variable and set the data from it. Byte
+  // offsets of all registers are calculated wrt 'UserArea' structure.
+  // However, ReadFPR() reads fpu registers {using
+  // ptrace(PT_GETFPREGS,..)} and stores them in 'm_fpr' (of type FPR
+  // structure). To extract values of fpu registers, m_fpr should be read
+  // at byte offsets calculated wrt to FPR structure.
 
   // Since, FPR structure is also one of the member of UserArea structure.
   // byte_offset(fpu wrt FPR) = byte_offset(fpu wrt UserArea) -
@@ -291,24 +293,24 @@
         if (GetFPRType() != eXSAVE)
           return false; // the target processor does not support AVX
 
-        // Store ymm register content, and split into the register halves in
-        // xmm.bytes and ymmh.bytes
+        // Store ymm register content, and split into the register halves
+        // in xmm.bytes and ymmh.bytes
         ::memcpy(m_ymm_set.ymm[reg - m_reg_info.first_ymm].bytes,
                  value.GetBytes(), value.GetByteSize());
         if (false == CopyYMMtoXSTATE(reg, GetByteOrder()))
           return false;
       }
     } else {
-      // Get pointer to m_fpr.fxsave variable and set the data to it.
-      // Byte offsets of all registers are calculated wrt 'UserArea' structure.
-      // However, WriteFPR() takes m_fpr (of type FPR structure) and writes only
-      // fpu
-      // registers using ptrace(PT_SETFPREGS,..) API. Hence fpu registers should
-      // be written in m_fpr at byte offsets calculated wrt FPR structure.
-
-      // Since, FPR structure is also one of the member of UserArea structure.
-      // byte_offset(fpu wrt FPR) = byte_offset(fpu wrt UserArea) -
-      // byte_offset(fctrl wrt UserArea)
+      // Get pointer to m_fpr.fxsave variable and set the data to it. Byte
+      // offsets of all registers are calculated wrt 'UserArea' structure.
+      // However, WriteFPR() takes m_fpr (of type FPR structure) and
+      // writes only fpu registers using ptrace(PT_SETFPREGS,..) API.
+      // Hence fpu registers should be written in m_fpr at byte offsets
+      // calculated wrt FPR structure.
+
+      // Since, FPR structure is also one of the member of UserArea
+      // structure. byte_offset(fpu wrt FPR) = byte_offset(fpu wrt
+      // UserArea) - byte_offset(fctrl wrt UserArea)
       assert((reg_info->byte_offset - m_fctrl_offset_in_userarea) <
              sizeof(m_fpr));
       uint8_t *dst = (uint8_t *)&m_fpr + reg_info->byte_offset -
@@ -566,7 +568,8 @@
   if (!IsWatchpointVacant(hw_index))
     return false;
 
-  // Set both dr7 (debug control register) and dri (debug address register).
+  // Set both dr7 (debug control register) and dri (debug address
+  // register).
 
   // dr7{7-0} encodes the local/global enable bits:
   //  global enable --. .-- local enable
Index: source/Plugins/Process/Linux/NativeProcessLinux.cpp
===================================================================
--- source/Plugins/Process/Linux/NativeProcessLinux.cpp
+++ source/Plugins/Process/Linux/NativeProcessLinux.cpp
@@ -85,8 +85,8 @@
     local.iov_base = &dest;
     remote.iov_len = local.iov_len = sizeof source;
 
-    // We shall try if cross-process-memory reads work by attempting to read a
-    // value from our own process.
+    // We shall try if cross-process-memory reads work by attempting to
+    // read a value from our own process.
     ssize_t res = process_vm_readv(getpid(), &local, 1, &remote, 1, 0);
     is_supported = (res == sizeof(source) && source == dest);
     if (is_supported)
@@ -337,8 +337,8 @@
         // Attach to the requested process.
         // An attach will cause the thread to stop with a SIGSTOP.
         if ((status = PtraceWrapper(PTRACE_ATTACH, tid)).Fail()) {
-          // No such thread. The thread may have exited.
-          // More error handling may be needed.
+          // No such thread. The thread may have exited. More error
+          // handling may be needed.
           if (status.GetError() == ESRCH) {
             it = tids_to_attach.erase(it);
             continue;
@@ -348,11 +348,12 @@
 
         int wpid =
             llvm::sys::RetryAfterSignal(-1, ::waitpid, tid, nullptr, __WALL);
-        // Need to use __WALL otherwise we receive an error with errno=ECHLD
-        // At this point we should have a thread stopped if waitpid succeeds.
+        // Need to use __WALL otherwise we receive an error with
+        // errno=ECHLD At this point we should have a thread stopped if
+        // waitpid succeeds.
         if (wpid < 0) {
-          // No such thread. The thread may have exited.
-          // More error handling may be needed.
+          // No such thread. The thread may have exited. More error
+          // handling may be needed.
           if (errno == ESRCH) {
             it = tids_to_attach.erase(it);
             continue;
@@ -388,17 +389,18 @@
 Status NativeProcessLinux::SetDefaultPtraceOpts(lldb::pid_t pid) {
   long ptrace_opts = 0;
 
-  // Have the child raise an event on exit.  This is used to keep the child in
-  // limbo until it is destroyed.
+  // Have the child raise an event on exit.  This is used to keep the
+  // child in limbo until it is destroyed.
   ptrace_opts |= PTRACE_O_TRACEEXIT;
 
   // Have the tracer trace threads which spawn in the inferior process.
   // TODO: if we want to support tracing the inferiors' child, add the
-  // appropriate ptrace flags here (PTRACE_O_TRACEFORK, PTRACE_O_TRACEVFORK)
+  // appropriate ptrace flags here (PTRACE_O_TRACEFORK,
+  // PTRACE_O_TRACEVFORK)
   ptrace_opts |= PTRACE_O_TRACECLONE;
 
-  // Have the tracer notify us before execve returns
-  // (needed to disable legacy SIGTRAP generation)
+  // Have the tracer notify us before execve returns (needed to disable
+  // legacy SIGTRAP generation)
   ptrace_opts |= PTRACE_O_TRACEEXEC;
 
   return PtraceWrapper(PTRACE_SETOPTIONS, pid, nullptr, (void *)ptrace_opts);
@@ -409,8 +411,8 @@
                                          WaitStatus status) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
-  // Certain activities differ based on whether the pid is the tid of the main
-  // thread.
+  // Certain activities differ based on whether the pid is the tid of the
+  // main thread.
   const bool is_main_thread = (pid == GetID());
 
   // Handle when the thread exits.
@@ -420,11 +422,13 @@
              "state = {3}",
              signal, pid, is_main_thread ? "is" : "is not", GetState());
 
-    // This is a thread that exited.  Ensure we're not tracking it anymore.
+    // This is a thread that exited.  Ensure we're not tracking it
+    // anymore.
     StopTrackingThread(pid);
 
     if (is_main_thread) {
-      // The main thread exited.  We're done monitoring.  Report to delegate.
+      // The main thread exited.  We're done monitoring.  Report to
+      // delegate.
       SetExitStatus(status, true);
 
       // Notify delegate that our process has exited.
@@ -438,9 +442,9 @@
   auto thread_sp = GetThreadByID(pid);
 
   if (!thread_sp) {
-    // Normally, the only situation when we cannot find the thread is if we have
-    // just received a new thread notification. This is indicated by
-    // GetSignalInfo() returning si_code == SI_USER and si_pid == 0
+    // Normally, the only situation when we cannot find the thread is if
+    // we have just received a new thread notification. This is indicated
+    // by GetSignalInfo() returning si_code == SI_USER and si_pid == 0
     LLDB_LOG(log, "received notification about an unknown tid {0}.", pid);
 
     if (info_err.Fail()) {
@@ -471,15 +475,15 @@
       MonitorSignal(info, *thread_sp, exited);
   } else {
     if (info_err.GetError() == EINVAL) {
-      // This is a group stop reception for this tid.
-      // We can reach here if we reinject SIGSTOP, SIGSTP, SIGTTIN or SIGTTOU
-      // into the tracee, triggering the group-stop mechanism. Normally
-      // receiving these would stop the process, pending a SIGCONT. Simulating
-      // this state in a debugger is hard and is generally not needed (one use
-      // case is debugging background task being managed by a shell). For
-      // general use, it is sufficient to stop the process in a signal-delivery
-      // stop which happens before the group stop. This done by MonitorSignal
-      // and works correctly for all signals.
+      // This is a group stop reception for this tid. We can reach here if
+      // we reinject SIGSTOP, SIGSTP, SIGTTIN or SIGTTOU into the tracee,
+      // triggering the group-stop mechanism. Normally receiving these
+      // would stop the process, pending a SIGCONT. Simulating this state
+      // in a debugger is hard and is generally not needed (one use case
+      // is debugging background task being managed by a shell). For
+      // general use, it is sufficient to stop the process in a signal-
+      // delivery stop which happens before the group stop. This done by
+      // MonitorSignal and works correctly for all signals.
       LLDB_LOG(log,
                "received a group stop for pid {0} tid {1}. Transparent "
                "handling of group stops not supported, resuming the "
@@ -490,12 +494,12 @@
     } else {
       // ptrace(GETSIGINFO) failed (but not due to group-stop).
 
-      // A return value of ESRCH means the thread/process is no longer on the
-      // system, so it was killed somehow outside of our control.  Either way,
-      // we can't do anything with it anymore.
+      // A return value of ESRCH means the thread/process is no longer on
+      // the system, so it was killed somehow outside of our control.
+      // Either way, we can't do anything with it anymore.
 
-      // Stop tracking the metadata for the thread since it's entirely off the
-      // system now.
+      // Stop tracking the metadata for the thread since it's entirely off
+      // the system now.
       const bool thread_found = StopTrackingThread(pid);
 
       LLDB_LOG(log,
@@ -504,14 +508,14 @@
                info_err, pid, signal, status, is_main_thread, thread_found);
 
       if (is_main_thread) {
-        // Notify the delegate - our process is not available but appears to
-        // have been killed outside
-        // our control.  Is eStateExited the right exit state in this case?
+        // Notify the delegate - our process is not available but appears
+        // to have been killed outside our control.  Is eStateExited the
+        // right exit state in this case?
         SetExitStatus(status, true);
         SetState(StateType::eStateExited, true);
       } else {
-        // This thread was pulled out from underneath us.  Anything to do here?
-        // Do we want to do an all stop?
+        // This thread was pulled out from underneath us.  Anything to do
+        // here? Do we want to do an all stop?
         LLDB_LOG(log,
                  "pid {0} tid {1} non-main thread exit occurred, didn't "
                  "tell delegate anything since thread disappeared out "
@@ -526,8 +530,8 @@
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 
   if (GetThreadByID(tid)) {
-    // We are already tracking the thread - we got the event on the new thread
-    // (see MonitorSignal) before this one. We are done.
+    // We are already tracking the thread - we got the event on the new
+    // thread (see MonitorSignal) before this one. We are done.
     return;
   }
 
@@ -538,16 +542,16 @@
            "yet, waiting for thread to appear...",
            tid);
   ::pid_t wait_pid = llvm::sys::RetryAfterSignal(-1, ::waitpid, tid, &status, __WALL);
-  // Since we are waiting on a specific tid, this must be the creation event.
-  // But let's do some checks just in case.
+  // Since we are waiting on a specific tid, this must be the creation
+  // event. But let's do some checks just in case.
   if (wait_pid != tid) {
     LLDB_LOG(log,
              "waiting for tid {0} failed. Assuming the thread has "
              "disappeared in the meantime",
              tid);
-    // The only way I know of this could happen is if the whole process was
-    // SIGKILLed in the mean time. In any case, we can't do anything about that
-    // now.
+    // The only way I know of this could happen is if the whole process
+    // was SIGKILLed in the mean time. In any case, we can't do anything
+    // about that now.
     return;
   }
   if (WIFEXITED(status)) {
@@ -574,20 +578,16 @@
   assert(info.si_signo == SIGTRAP && "Unexpected child signal!");
 
   switch (info.si_code) {
-  // TODO: these two cases are required if we want to support tracing of the
-  // inferiors' children.  We'd need this to debug a monitor.
-  // case (SIGTRAP | (PTRACE_EVENT_FORK << 8)):
-  // case (SIGTRAP | (PTRACE_EVENT_VFORK << 8)):
+  // TODO: these two cases are required if we want to support tracing of
+  // the inferiors' children.  We'd need this to debug a monitor. case
+  // (SIGTRAP | (PTRACE_EVENT_FORK << 8)): case (SIGTRAP |
+  // (PTRACE_EVENT_VFORK << 8)):
 
   case (SIGTRAP | (PTRACE_EVENT_CLONE << 8)): {
-    // This is the notification on the parent thread which informs us of new
-    // thread
-    // creation.
-    // We don't want to do anything with the parent thread so we just resume it.
-    // In case we
-    // want to implement "break on thread creation" functionality, we would need
-    // to stop
-    // here.
+    // This is the notification on the parent thread which informs us of
+    // new thread creation. We don't want to do anything with the parent
+    // thread so we just resume it. In case we want to implement "break on
+    // thread creation" functionality, we would need to stop here.
 
     unsigned long event_message = 0;
     if (GetEventMessage(thread.GetID(), &event_message).Fail()) {
@@ -608,8 +608,8 @@
     // Exec clears any pending notifications.
     m_pending_notification_tid = LLDB_INVALID_THREAD_ID;
 
-    // Remove all but the main thread here.  Linux fork creates a new process
-    // which only copies the main thread.
+    // Remove all but the main thread here.  Linux fork creates a new
+    // process which only copies the main thread.
     LLDB_LOG(log, "exec received, stop tracking all but main thread");
 
     for (auto i = m_threads.begin(); i != m_threads.end();) {
@@ -624,7 +624,8 @@
     SetCurrentThreadID(main_thread->GetID());
     main_thread->SetStoppedByExec();
 
-    // Tell coordinator about about the "new" (since exec) stopped main thread.
+    // Tell coordinator about about the "new" (since exec) stopped main
+    // thread.
     ThreadWasCreated(*main_thread);
 
     // Let our delegate know we have just exec'd.
@@ -637,10 +638,10 @@
   }
 
   case (SIGTRAP | (PTRACE_EVENT_EXIT << 8)): {
-    // The inferior process or one of its threads is about to exit.
-    // We don't want to do anything with the thread so we just resume it. In
-    // case we want to implement "break on thread exit" functionality, we would
-    // need to stop here.
+    // The inferior process or one of its threads is about to exit. We
+    // don't want to do anything with the thread so we just resume it. In
+    // case we want to implement "break on thread exit" functionality, we
+    // would need to stop here.
 
     unsigned long data = 0;
     if (GetEventMessage(thread.GetID(), &data).Fail())
@@ -655,11 +656,11 @@
 
     StateType state = thread.GetState();
     if (!StateIsRunningState(state)) {
-      // Due to a kernel bug, we may sometimes get this stop after the inferior
-      // gets a SIGKILL. This confuses our state tracking logic in
-      // ResumeThread(), since normally, we should not be receiving any ptrace
-      // events while the inferior is stopped. This makes sure that the inferior
-      // is resumed and exits normally.
+      // Due to a kernel bug, we may sometimes get this stop after the
+      // inferior gets a SIGKILL. This confuses our state tracking logic
+      // in ResumeThread(), since normally, we should not be receiving any
+      // ptrace events while the inferior is stopped. This makes sure that
+      // the inferior is resumed and exits normally.
       state = eStateRunning;
     }
     ResumeThread(thread, state, LLDB_INVALID_SIGNAL_NUMBER);
@@ -705,8 +706,8 @@
 
   case SI_KERNEL:
 #if defined __mips__
-    // For mips there is no special signal for watchpoint
-    // So we check for watchpoint in kernel trap
+    // For mips there is no special signal for watchpoint So we check for
+    // watchpoint in kernel trap
     {
       // If a watchpoint was hit, report it
       uint32_t wp_index;
@@ -782,12 +783,12 @@
   LLDB_LOG(log, "received watchpoint event, pid = {0}, wp_index = {1}",
            thread.GetID(), wp_index);
 
-  // Mark the thread as stopped at watchpoint.
-  // The address is at (lldb::addr_t)info->si_addr if we need it.
+  // Mark the thread as stopped at watchpoint. The address is at
+  // (lldb::addr_t)info->si_addr if we need it.
   thread.SetStoppedByWatchpoint(wp_index);
 
-  // We need to tell all other running threads before we notify the delegate
-  // about this stop.
+  // We need to tell all other running threads before we notify the
+  // delegate about this stop.
   StopRunningThreads(thread.GetID());
 }
 
@@ -798,9 +799,9 @@
 
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 
-  // POSIX says that process behaviour is undefined after it ignores a SIGFPE,
-  // SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated by a
-  // kill(2) or raise(3).  Similarly for tgkill(2) on Linux.
+  // POSIX says that process behaviour is undefined after it ignores a
+  // SIGFPE, SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated
+  // by a kill(2) or raise(3).  Similarly for tgkill(2) on Linux.
   //
   // IOW, user generated signals never generate what we consider to be a
   // "crash".
@@ -819,22 +820,23 @@
     // This is a tgkill()-based stop.
     LLDB_LOG(log, "pid {0} tid {1}, thread stopped", GetID(), thread.GetID());
 
-    // Check that we're not already marked with a stop reason.
-    // Note this thread really shouldn't already be marked as stopped - if we
-    // were, that would imply that the kernel signaled us with the thread
-    // stopping which we handled and marked as stopped, and that, without an
-    // intervening resume, we received another stop.  It is more likely that we
-    // are missing the marking of a run state somewhere if we find that the
-    // thread was marked as stopped.
+    // Check that we're not already marked with a stop reason. Note this
+    // thread really shouldn't already be marked as stopped - if we were,
+    // that would imply that the kernel signaled us with the thread
+    // stopping which we handled and marked as stopped, and that, without
+    // an intervening resume, we received another stop.  It is more likely
+    // that we are missing the marking of a run state somewhere if we find
+    // that the thread was marked as stopped.
     const StateType thread_state = thread.GetState();
     if (!StateIsStoppedState(thread_state, false)) {
-      // An inferior thread has stopped because of a SIGSTOP we have sent it.
-      // Generally, these are not important stops and we don't want to report
-      // them as they are just used to stop other threads when one thread (the
-      // one with the *real* stop reason) hits a breakpoint (watchpoint,
-      // etc...). However, in the case of an asynchronous Interrupt(), this *is*
-      // the real stop reason, so we leave the signal intact if this is the
-      // thread that was chosen as the triggering thread.
+      // An inferior thread has stopped because of a SIGSTOP we have sent
+      // it. Generally, these are not important stops and we don't want to
+      // report them as they are just used to stop other threads when one
+      // thread (the one with the *real* stop reason) hits a breakpoint
+      // (watchpoint, etc...). However, in the case of an asynchronous
+      // Interrupt(), this *is* the real stop reason, so we leave the
+      // signal intact if this is the thread that was chosen as the
+      // triggering thread.
       if (m_pending_notification_tid != LLDB_INVALID_THREAD_ID) {
         if (m_pending_notification_tid == thread.GetID())
           thread.SetStoppedBySignal(SIGSTOP, &info);
@@ -844,8 +846,9 @@
         SetCurrentThreadID(thread.GetID());
         SignalIfAllThreadsStopped();
       } else {
-        // We can end up here if stop was initiated by LLGS but by this time a
-        // thread stop has occurred - maybe initiated by another event.
+        // We can end up here if stop was initiated by LLGS but by this
+        // time a thread stop has occurred - maybe initiated by another
+        // event.
         Status error = ResumeThread(thread, thread.GetState(), 0);
         if (error.Fail())
           LLDB_LOG(log, "failed to resume thread {0}: {1}", thread.GetID(),
@@ -863,8 +866,8 @@
     return;
   }
 
-  // Check if debugger should stop at this signal or just ignore it
-  // and resume the inferior.
+  // Check if debugger should stop at this signal or just ignore it and
+  // resume the inferior.
   if (m_signals_to_ignore.find(signo) != m_signals_to_ignore.end()) {
      ResumeThread(thread, thread.GetState(), signo);
      return;
@@ -915,9 +918,9 @@
     return true;
   }
 
-  // The emulator only fill in the dwarf regsiter numbers (and in some case
-  // the generic register numbers). Get the full register info from the
-  // register context based on the dwarf register numbers.
+  // The emulator only fill in the dwarf regsiter numbers (and in some
+  // case the generic register numbers). Get the full register info from
+  // the register context based on the dwarf register numbers.
   const RegisterInfo *full_reg_info =
       emulator_baton->m_reg_context.GetRegisterInfo(
           eRegisterKindDWARF, reg_info->kinds[eRegisterKindDWARF]);
@@ -1002,15 +1005,15 @@
       next_flags = ReadFlags(register_context);
   } else if (pc_it == baton.m_register_values.end()) {
     // Emulate instruction failed and it haven't changed PC. Advance PC
-    // with the size of the current opcode because the emulation of all
-    // PC modifying instruction should be successful. The failure most
-    // likely caused by a not supported instruction which don't modify PC.
+    // with the size of the current opcode because the emulation of all PC
+    // modifying instruction should be successful. The failure most likely
+    // caused by a not supported instruction which don't modify PC.
     next_pc = register_context.GetPC() + emulator_ap->GetOpcode().GetByteSize();
     next_flags = ReadFlags(register_context);
   } else {
     // The instruction emulation failed after it modified the PC. It is an
-    // unknown error where we can't continue because the next instruction is
-    // modifying the PC but we don't  know how.
+    // unknown error where we can't continue because the next instruction
+    // is modifying the PC but we don't  know how.
     return Status("Instruction emulation failed unexpectedly.");
   }
 
@@ -1033,8 +1036,8 @@
     error = SetSoftwareBreakpoint(next_pc, 0);
   }
 
-  // If setting the breakpoint fails because next_pc is out of
-  // the address space, ignore it and let the debugee segfault.
+  // If setting the breakpoint fails because next_pc is out of the address
+  // space, ignore it and let the debugee segfault.
   if (error.GetError() == EIO || error.GetError() == EFAULT) {
     return Status();
   } else if (error.Fail())
@@ -1165,8 +1168,8 @@
 }
 
 Status NativeProcessLinux::Interrupt() {
-  // Pick a running thread (or if none, a not-dead stopped thread) as
-  // the chosen thread that will be the stop-reason thread.
+  // Pick a running thread (or if none, a not-dead stopped thread) as the
+  // chosen thread that will be the stop-reason thread.
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 
   NativeThreadProtocol *running_thread = nullptr;
@@ -1174,15 +1177,15 @@
 
   LLDB_LOG(log, "selecting running thread for interrupt target");
   for (const auto &thread : m_threads) {
-    // If we have a running or stepping thread, we'll call that the
-    // target of the interrupt.
+    // If we have a running or stepping thread, we'll call that the target
+    // of the interrupt.
     const auto thread_state = thread->GetState();
     if (thread_state == eStateRunning || thread_state == eStateStepping) {
       running_thread = thread.get();
       break;
     } else if (!stopped_thread && StateIsStoppedState(thread_state, true)) {
-      // Remember the first non-dead stopped thread.  We'll use that as a backup
-      // if there are no running threads.
+      // Remember the first non-dead stopped thread.  We'll use that as a
+      // backup if there are no running threads.
       stopped_thread = thread.get();
     }
   }
@@ -1250,10 +1253,9 @@
 
   StringExtractor line_extractor(maps_line);
 
-  // Format: {address_start_hex}-{address_end_hex} perms offset  dev   inode
-  // pathname
-  // perms: rwxp   (letter is present if set, '-' if not, final character is
-  // p=private, s=shared).
+  // Format: {address_start_hex}-{address_end_hex} perms offset  dev
+  // inode pathname perms: rwxp   (letter is present if set, '-' if not,
+  // final character is p=private, s=shared).
 
   // Parse out the starting address
   lldb::addr_t start_address = line_extractor.GetHexMaxU64(false, 0);
@@ -1275,8 +1277,8 @@
   memory_region_info.GetRange().SetRangeBase(start_address);
   memory_region_info.GetRange().SetRangeEnd(end_address);
 
-  // Any memory region in /proc/{pid}/maps is by definition mapped into the
-  // process.
+  // Any memory region in /proc/{pid}/maps is by definition mapped into
+  // the process.
   memory_region_info.SetMapped(MemoryRegionInfo::OptionalBool::eYes);
 
   // Parse out each permission entry.
@@ -1330,13 +1332,12 @@
 
 Status NativeProcessLinux::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                                MemoryRegionInfo &range_info) {
-  // FIXME review that the final memory region returned extends to the end of
-  // the virtual address space,
-  // with no perms if it is not mapped.
+  // FIXME review that the final memory region returned extends to the end
+  // of the virtual address space, with no perms if it is not mapped.
 
   // Use an approach that reads memory regions from /proc/{pid}/maps.
-  // Assume proc maps entries are in ascending order.
-  // FIXME assert if we find differently.
+  // Assume proc maps entries are in ascending order. FIXME assert if we
+  // find differently.
 
   if (m_supports_mem_region == LazyBool::eLazyBoolNo) {
     // We're done.
@@ -1350,21 +1351,22 @@
 
   lldb::addr_t prev_base_address = 0;
 
-  // FIXME start by finding the last region that is <= target address using
-  // binary search.  Data is sorted.
-  // There can be a ton of regions on pthreads apps with lots of threads.
+  // FIXME start by finding the last region that is <= target address
+  // using binary search.  Data is sorted. There can be a ton of regions
+  // on pthreads apps with lots of threads.
   for (auto it = m_mem_region_cache.begin(); it != m_mem_region_cache.end();
        ++it) {
     MemoryRegionInfo &proc_entry_info = it->first;
 
-    // Sanity check assumption that /proc/{pid}/maps entries are ascending.
+    // Sanity check assumption that /proc/{pid}/maps entries are
+    // ascending.
     assert((proc_entry_info.GetRange().GetRangeBase() >= prev_base_address) &&
            "descending /proc/pid/maps entries detected, unexpected");
     prev_base_address = proc_entry_info.GetRange().GetRangeBase();
     UNUSED_IF_ASSERT_DISABLED(prev_base_address);
 
-    // If the target address comes before this entry, indicate distance to next
-    // region.
+    // If the target address comes before this entry, indicate distance to
+    // next region.
     if (load_addr < proc_entry_info.GetRange().GetRangeBase()) {
       range_info.GetRange().SetRangeBase(load_addr);
       range_info.GetRange().SetByteSize(
@@ -1376,7 +1378,8 @@
 
       return error;
     } else if (proc_entry_info.GetRange().Contains(load_addr)) {
-      // The target address is within the memory region we're processing here.
+      // The target address is within the memory region we're processing
+      // here.
       range_info = proc_entry_info;
       return error;
     }
@@ -1386,10 +1389,8 @@
   }
 
   // If we made it here, we didn't find an entry that contained the given
-  // address. Return the
-  // load_addr as start and the amount of bytes betwwen load address and the end
-  // of the memory as
-  // size.
+  // address. Return the load_addr as start and the amount of bytes
+  // betwwen load address and the end of the memory as size.
   range_info.GetRange().SetRangeBase(load_addr);
   range_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
   range_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
@@ -1402,8 +1403,8 @@
 Status NativeProcessLinux::PopulateMemoryRegionCache() {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 
-  // If our cache is empty, pull the latest.  There should always be at least
-  // one memory region if memory region handling is supported.
+  // If our cache is empty, pull the latest.  There should always be at
+  // least one memory region if memory region handling is supported.
   if (!m_mem_region_cache.empty()) {
     LLDB_LOG(log, "reusing {0} cached memory region entries",
              m_mem_region_cache.size());
@@ -1462,8 +1463,8 @@
 Status NativeProcessLinux::AllocateMemory(size_t size, uint32_t permissions,
                                           lldb::addr_t &addr) {
 // FIXME implementing this requires the equivalent of
-// InferiorCallPOSIX::InferiorCallMmap, which depends on
-// functional ThreadPlans working with Native*Protocol.
+// InferiorCallPOSIX::InferiorCallMmap, which depends on functional
+// ThreadPlans working with Native*Protocol.
 #if 1
   return Status("not implemented yet");
 #else
@@ -1477,9 +1478,8 @@
   if (permissions & lldb::ePermissionsExecutable)
     prot |= eMmapProtExec;
 
-  // TODO implement this directly in NativeProcessLinux
-  // (and lift to NativeProcessPOSIX if/when that class is
-  // refactored out).
+  // TODO implement this directly in NativeProcessLinux (and lift to
+  // NativeProcessPOSIX if/when that class is refactored out).
   if (InferiorCallMmap(this, addr, 0, size, prot,
                        eMmapFlagsAnon | eMmapFlagsPrivate, -1, 0)) {
     m_addr_to_mmap_size[addr] = size;
@@ -1494,8 +1494,8 @@
 }
 
 Status NativeProcessLinux::DeallocateMemory(lldb::addr_t addr) {
-  // FIXME see comments in AllocateMemory - required lower-level
-  // bits not in place yet (ThreadPlans)
+  // FIXME see comments in AllocateMemory - required lower-level bits not
+  // in place yet (ThreadPlans)
   return Status("not implemented");
 }
 
@@ -1505,17 +1505,16 @@
 }
 
 size_t NativeProcessLinux::UpdateThreads() {
-  // The NativeProcessLinux monitoring threads are always up to date
-  // with respect to thread state and they keep the thread list
-  // populated properly. All this method needs to do is return the
-  // thread count.
+  // The NativeProcessLinux monitoring threads are always up to date with
+  // respect to thread state and they keep the thread list populated
+  // properly. All this method needs to do is return the thread count.
   return m_threads.size();
 }
 
 Status NativeProcessLinux::GetSoftwareBreakpointPCOffset(
     uint32_t &actual_opcode_size) {
-  // FIXME put this behind a breakpoint protocol class that can be
-  // set per architecture.  Need ARM, MIPS support here.
+  // FIXME put this behind a breakpoint protocol class that can be set per
+  // architecture.  Need ARM, MIPS support here.
   static const uint8_t g_i386_opcode[] = {0xCC};
   static const uint8_t g_s390x_opcode[] = {0x00, 0x01};
 
@@ -1647,9 +1646,9 @@
         assert(false && "unexpected si_code for SIGSEGV");
         break;
     case SI_KERNEL:
-        // Linux will occasionally send spurious SI_KERNEL codes.
-        // (this is poorly documented in sigaction)
-        // One way to get this is via unaligned SIMD loads.
+        // Linux will occasionally send spurious SI_KERNEL codes. (this is
+        // poorly documented in sigaction) One way to get this is via
+        // unaligned SIMD loads.
         reason = ProcessMessage::eInvalidAddress; // for lack of anything better
         break;
     case SEGV_MAPERR:
@@ -1784,9 +1783,8 @@
 Status NativeProcessLinux::ReadMemory(lldb::addr_t addr, void *buf, size_t size,
                                       size_t &bytes_read) {
   if (ProcessVmReadvSupported()) {
-    // The process_vm_readv path is about 50 times faster than ptrace api. We
-    // want to use
-    // this syscall if it is supported.
+    // The process_vm_readv path is about 50 times faster than ptrace api.
+    // We want to use this syscall if it is supported.
 
     const ::pid_t pid = GetID();
 
@@ -1807,8 +1805,8 @@
 
     if (success)
       return Status();
-    // else the call failed for some reason, let's retry the read using ptrace
-    // api.
+    // else the call failed for some reason, let's retry the read using
+    // ptrace api.
   }
 
   unsigned char *dst = static_cast<unsigned char *>(buf);
@@ -1976,8 +1974,8 @@
 
   Status error;
 
-  // Find out the size of a breakpoint (might depend on where we are in the
-  // code).
+  // Find out the size of a breakpoint (might depend on where we are in
+  // the code).
   NativeRegisterContext &context = thread.GetRegisterContext();
 
   uint32_t breakpoint_size = 0;
@@ -1988,8 +1986,8 @@
   } else
     LLDB_LOG(log, "breakpoint size: {0}", breakpoint_size);
 
-  // First try probing for a breakpoint at a software breakpoint location: PC -
-  // breakpoint size.
+  // First try probing for a breakpoint at a software breakpoint location:
+  // PC - breakpoint size.
   const lldb::addr_t initial_pc_addr = context.GetPCfromBreakpointLocation();
   lldb::addr_t breakpoint_addr = initial_pc_addr;
   if (breakpoint_size > 0) {
@@ -2093,12 +2091,11 @@
   Log *const log = ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD);
   LLDB_LOG(log, "tid: {0}", thread.GetID());
 
-  // Before we do the resume below, first check if we have a pending
-  // stop notification that is currently waiting for
-  // all threads to stop.  This is potentially a buggy situation since
-  // we're ostensibly waiting for threads to stop before we send out the
-  // pending notification, and here we are resuming one before we send
-  // out the pending stop notification.
+  // Before we do the resume below, first check if we have a pending stop
+  // notification that is currently waiting for all threads to stop.  This
+  // is potentially a buggy situation since we're ostensibly waiting for
+  // threads to stop before we send out the pending notification, and here
+  // we are resuming one before we send out the pending stop notification.
   if (m_pending_notification_tid != LLDB_INVALID_THREAD_ID) {
     LLDB_LOG(log,
              "about to resume tid {0} per explicit request but we have a "
@@ -2107,8 +2104,8 @@
              thread.GetID(), m_pending_notification_tid);
   }
 
-  // Request a resume.  We expect this to be synchronous and the system
-  // to reflect it is running after this completes.
+  // Request a resume.  We expect this to be synchronous and the system to
+  // reflect it is running after this completes.
   switch (state) {
   case eStateRunning: {
     const auto resume_result = thread.Resume(signo);
@@ -2137,8 +2134,8 @@
 
   m_pending_notification_tid = triggering_tid;
 
-  // Request a stop for all the thread stops that need to be stopped
-  // and are not already known to be stopped.
+  // Request a stop for all the thread stops that need to be stopped and
+  // are not already known to be stopped.
   for (const auto &thread : m_threads) {
     if (StateIsRunningState(thread->GetState()))
       static_cast<NativeThreadLinux *>(thread.get())->RequestStop();
@@ -2183,9 +2180,8 @@
 
   if (m_pending_notification_tid != LLDB_INVALID_THREAD_ID &&
       StateIsRunningState(thread.GetState())) {
-    // We will need to wait for this new thread to stop as well before firing
-    // the
-    // notification.
+    // We will need to wait for this new thread to stop as well before
+    // firing the notification.
     thread.RequestStop();
   }
 }
@@ -2221,9 +2217,8 @@
   }
 }
 
-// Wrapper for ptrace to catch errors and log calls.
-// Note that ptrace sets errno on error because -1 can be a valid result (i.e.
-// for PTRACE_PEEK*)
+// Wrapper for ptrace to catch errors and log calls. Note that ptrace sets
+// errno on error because -1 can be a valid result (i.e. for PTRACE_PEEK*)
 Status NativeProcessLinux::PtraceWrapper(int req, lldb::pid_t pid, void *addr,
                                          void *data, size_t data_size,
                                          long *result) {
@@ -2473,8 +2468,8 @@
   if (thread == LLDB_INVALID_THREAD_ID) {
     for (auto& iter : m_processor_trace_monitor) {
       if (iter.second->GetTraceID() == traceid) {
-        // Stopping a trace instance for an individual thread
-        // hence there will only be one traceid that can match.
+        // Stopping a trace instance for an individual thread hence there
+        // will only be one traceid that can match.
         m_processor_trace_monitor.erase(iter.first);
         return error;
       }
Index: source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp
===================================================================
--- source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp
+++ source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp
@@ -130,7 +130,8 @@
   ::memset(&m_hwp_regs, 0, sizeof(m_hwp_regs));
   ::memset(&m_hbr_regs, 0, sizeof(m_hbr_regs));
 
-  // 16 is just a maximum value, query hardware for actual watchpoint count
+  // 16 is just a maximum value, query hardware for actual watchpoint
+  // count
   m_max_hwp_supported = 16;
   m_max_hbp_supported = 16;
   m_refresh_hwdebug_info = true;
@@ -184,14 +185,14 @@
     error = ReadRegisterRaw(full_reg, reg_value);
 
     if (error.Success()) {
-      // If our read was not aligned (for ah,bh,ch,dh), shift our returned value
-      // one byte to the right.
+      // If our read was not aligned (for ah,bh,ch,dh), shift our returned
+      // value one byte to the right.
       if (is_subreg && (reg_info->byte_offset & 0x1))
         reg_value.SetUInt64(reg_value.GetAsUInt64() >> 8);
 
-      // If our return byte size was greater than the return value reg size,
-      // then
-      // use the type specified by reg_info rather than the uint64_t default
+      // If our return byte size was greater than the return value reg
+      // size, then use the type specified by reg_info rather than the
+      // uint64_t default
       if (reg_value.GetByteSize() > reg_info->byte_size)
         reg_value.SetType(reg_info);
     }
@@ -558,8 +559,8 @@
   uint32_t control_value = 0, wp_index = 0, addr_word_offset = 0, byte_mask = 0;
   lldb::addr_t real_addr = addr;
 
-  // Check if we are setting watchpoint other than read/write/access
-  // Also update watchpoint flag to match Arm write-read bit configuration.
+  // Check if we are setting watchpoint other than read/write/access Also
+  // update watchpoint flag to match Arm write-read bit configuration.
   switch (watch_flags) {
   case 1:
     watch_flags = 2;
@@ -579,9 +580,9 @@
   if (size == 0 || size > 4)
     return LLDB_INVALID_INDEX32;
 
-  // Check 4-byte alignment for hardware watchpoint target address.
-  // Below is a hack to recalculate address and size in order to
-  // make sure we can watch non 4-byte alligned addresses as well.
+  // Check 4-byte alignment for hardware watchpoint target address. Below
+  // is a hack to recalculate address and size in order to make sure we
+  // can watch non 4-byte alligned addresses as well.
   if (addr & 0x03) {
     uint8_t watch_mask = (addr & 0x03) + size;
 
@@ -595,8 +596,9 @@
     addr = addr & (~0x03);
   }
 
-  // We can only watch up to four bytes that follow a 4 byte aligned address
-  // per watchpoint register pair, so make sure we can properly encode this.
+  // We can only watch up to four bytes that follow a 4 byte aligned
+  // address per watchpoint register pair, so make sure we can properly
+  // encode this.
   addr_word_offset = addr % 4;
   byte_mask = ((1u << size) - 1u) << addr_word_offset;
 
@@ -873,13 +875,11 @@
 Status NativeRegisterContextLinux_arm::DoReadRegisterValue(
     uint32_t offset, const char *reg_name, uint32_t size,
     RegisterValue &value) {
-  // PTRACE_PEEKUSER don't work in the aarch64 linux kernel used on android
-  // devices (always return
-  // "Bad address"). To avoid using PTRACE_PEEKUSER we read out the full GPR
-  // register set instead.
-  // This approach is about 4 times slower but the performance overhead is
-  // negligible in
-  // comparision to processing time in lldb-server.
+  // PTRACE_PEEKUSER don't work in the aarch64 linux kernel used on
+  // android devices (always return "Bad address"). To avoid using
+  // PTRACE_PEEKUSER we read out the full GPR register set instead. This
+  // approach is about 4 times slower but the performance overhead is
+  // negligible in comparision to processing time in lldb-server.
   assert(offset % 4 == 0 && "Try to write a register with unaligned offset");
   if (offset + sizeof(uint32_t) > sizeof(m_gpr_arm))
     return Status("Register isn't fit into the size of the GPR area");
@@ -894,14 +894,12 @@
 
 Status NativeRegisterContextLinux_arm::DoWriteRegisterValue(
     uint32_t offset, const char *reg_name, const RegisterValue &value) {
-  // PTRACE_POKEUSER don't work in the aarch64 linux kernel used on android
-  // devices (always return
-  // "Bad address"). To avoid using PTRACE_POKEUSER we read out the full GPR
-  // register set, modify
-  // the requested register and write it back. This approach is about 4 times
-  // slower but the
-  // performance overhead is negligible in comparision to processing time in
-  // lldb-server.
+  // PTRACE_POKEUSER don't work in the aarch64 linux kernel used on
+  // android devices (always return "Bad address"). To avoid using
+  // PTRACE_POKEUSER we read out the full GPR register set, modify the
+  // requested register and write it back. This approach is about 4 times
+  // slower but the performance overhead is negligible in comparision to
+  // processing time in lldb-server.
   assert(offset % 4 == 0 && "Try to write a register with unaligned offset");
   if (offset + sizeof(uint32_t) > sizeof(m_gpr_arm))
     return Status("Register isn't fit into the size of the GPR area");
@@ -911,13 +909,13 @@
     return error;
 
   uint32_t reg_value = value.GetAsUInt32();
-  // As precaution for an undefined behavior encountered while setting PC we
-  // will clear thumb bit of new PC if we are already in thumb mode; that is
-  // CPSR thumb mode bit is set.
+  // As precaution for an undefined behavior encountered while setting PC
+  // we will clear thumb bit of new PC if we are already in thumb mode;
+  // that is CPSR thumb mode bit is set.
   if (offset / sizeof(uint32_t) == gpr_pc_arm) {
-    // Check if we are already in thumb mode and
-    // thumb bit of current PC is read out to be zero and
-    // thumb bit of next PC is read out to be one.
+    // Check if we are already in thumb mode and thumb bit of current PC
+    // is read out to be zero and thumb bit of next PC is read out to be
+    // one.
     if ((m_gpr_arm[gpr_cpsr_arm] & 0x20) && !(m_gpr_arm[gpr_pc_arm] & 0x01) &&
         (value.GetAsUInt32() & 0x01)) {
       reg_value &= (~1ull);
Index: source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp
===================================================================
--- source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp
+++ source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp
@@ -27,9 +27,9 @@
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
 
-// System includes - They have to be included after framework includes because
-// they define some
-// macros which collide with variable names in other modules
+// System includes - They have to be included after framework includes
+// because they define some macros which collide with variable names in
+// other modules
 #include <sys/socket.h>
 // NT_PRSTATUS and NT_FPREGSET definition
 #include <elf.h>
@@ -153,7 +153,8 @@
   ::memset(&m_hwp_regs, 0, sizeof(m_hwp_regs));
   ::memset(&m_hbr_regs, 0, sizeof(m_hbr_regs));
 
-  // 16 is just a maximum value, query hardware for actual watchpoint count
+  // 16 is just a maximum value, query hardware for actual watchpoint
+  // count
   m_max_hwp_supported = 16;
   m_max_hbp_supported = 16;
   m_refresh_hwdebug_info = true;
@@ -207,14 +208,14 @@
     error = ReadRegisterRaw(full_reg, reg_value);
 
     if (error.Success()) {
-      // If our read was not aligned (for ah,bh,ch,dh), shift our returned value
-      // one byte to the right.
+      // If our read was not aligned (for ah,bh,ch,dh), shift our returned
+      // value one byte to the right.
       if (is_subreg && (reg_info->byte_offset & 0x1))
         reg_value.SetUInt64(reg_value.GetAsUInt64() >> 8);
 
-      // If our return byte size was greater than the return value reg size,
-      // then
-      // use the type specified by reg_info rather than the uint64_t default
+      // If our return byte size was greater than the return value reg
+      // size, then use the type specified by reg_info rather than the
+      // uint64_t default
       if (reg_value.GetByteSize() > reg_info->byte_size)
         reg_value.SetType(reg_info);
     }
@@ -562,8 +563,8 @@
   uint32_t control_value = 0, wp_index = 0;
   lldb::addr_t real_addr = addr;
 
-  // Check if we are setting watchpoint other than read/write/access
-  // Also update watchpoint flag to match AArch64 write-read bit configuration.
+  // Check if we are setting watchpoint other than read/write/access Also
+  // update watchpoint flag to match AArch64 write-read bit configuration.
   switch (watch_flags) {
   case 1:
     watch_flags = 2;
@@ -581,9 +582,9 @@
   if (size != 1 && size != 2 && size != 4 && size != 8)
     return LLDB_INVALID_INDEX32;
 
-  // Check 8-byte alignment for hardware watchpoint target address.
-  // Below is a hack to recalculate address and size in order to
-  // make sure we can watch non 8-byte alligned addresses as well.
+  // Check 8-byte alignment for hardware watchpoint target address. Below
+  // is a hack to recalculate address and size in order to make sure we
+  // can watch non 8-byte alligned addresses as well.
   if (addr & 0x07) {
     uint8_t watch_mask = (addr & 0x07) + size;
 
Index: source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp
===================================================================
--- source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp
+++ source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp
@@ -140,9 +140,9 @@
     break;
   }
 
-  // Initialize m_iovec to point to the buffer and buffer size
-  // using the conventions of Berkeley style UIO structures, as required
-  // by PTRACE extensions.
+  // Initialize m_iovec to point to the buffer and buffer size using the
+  // conventions of Berkeley style UIO structures, as required by PTRACE
+  // extensions.
   m_iovec.iov_base = &m_msa;
   m_iovec.iov_len = sizeof(MSA_linux_mips);
 
@@ -255,8 +255,8 @@
   const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
   uint8_t byte_size = reg_info->byte_size;
   if (reg == LLDB_INVALID_REGNUM) {
-    // This is likely an internal register for lldb use only and should not be
-    // directly queried.
+    // This is likely an internal register for lldb use only and should
+    // not be directly queried.
     error.SetErrorStringWithFormat("register \"%s\" is an internal-only lldb "
                                    "register, cannot read directly",
                                    reg_info->name);
@@ -337,7 +337,8 @@
     uint8_t byte_size = reg_info->byte_size;
     lldbassert(reg_info->byte_offset < sizeof(UserArea));
 
-    // Initialise the FP and MSA buffers by reading all co-processor 1 registers
+    // Initialise the FP and MSA buffers by reading all co-processor 1
+    // registers
     ReadCP1();
 
     if (IsFPR(reg_index)) {
Index: source/Plugins/Process/Linux/NativeRegisterContextLinux_ppc64le.cpp
===================================================================
--- source/Plugins/Process/Linux/NativeRegisterContextLinux_ppc64le.cpp
+++ source/Plugins/Process/Linux/NativeRegisterContextLinux_ppc64le.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-// This implementation is related to the OpenPOWER ABI for Power Architecture
-// 64-bit ELF V2 ABI
+// This implementation is related to the OpenPOWER ABI for Power
+// Architecture 64-bit ELF V2 ABI
 
 #if defined(__powerpc64__)
 
@@ -25,9 +25,9 @@
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/RegisterInfoPOSIX_ppc64le.h"
 
-// System includes - They have to be included after framework includes because
-// they define some
-// macros which collide with variable names in other modules
+// System includes - They have to be included after framework includes
+// because they define some macros which collide with variable names in
+// other modules
 #include <sys/socket.h>
 #include <elf.h>
 #include <asm/ptrace.h>
@@ -591,9 +591,9 @@
   if (size != 1 && size != 2 && size != 4 && size != 8)
     return LLDB_INVALID_INDEX32;
 
-  // Check 8-byte alignment for hardware watchpoint target address.
-  // Below is a hack to recalculate address and size in order to
-  // make sure we can watch non 8-byte alligned addresses as well.
+  // Check 8-byte alignment for hardware watchpoint target address. Below
+  // is a hack to recalculate address and size in order to make sure we
+  // can watch non 8-byte alligned addresses as well.
   if (addr & 0x07) {
 
     addr_t begin = llvm::alignDown(addr, 8);
Index: source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.cpp
===================================================================
--- source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.cpp
+++ source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.cpp
@@ -309,7 +309,8 @@
     if (error.Fail())
       return error;
 
-    // byte_offset is just the offset within fp_regs, not the whole user area.
+    // byte_offset is just the offset within fp_regs, not the whole user
+    // area.
     uint8_t *dst = (uint8_t *)&fp_regs + reg_info->byte_offset;
     assert(reg_info->byte_offset + reg_info->byte_size <= sizeof(fp_regs));
     switch (reg_info->byte_size) {
@@ -368,13 +369,14 @@
   if (error.Fail())
     return error;
 
-  // Ignore errors if the regset is unsupported (happens on older kernels).
+  // Ignore errors if the regset is unsupported (happens on older
+  // kernels).
   DoReadRegisterSet(NT_S390_SYSTEM_CALL, dst, 4);
   dst += 4;
 
-  // To enable inferior function calls while the process is stopped in
-  // an interrupted system call, we need to clear the system call flag.
-  // It will be restored to its original value by WriteAllRegisterValues.
+  // To enable inferior function calls while the process is stopped in an
+  // interrupted system call, we need to clear the system call flag. It
+  // will be restored to its original value by WriteAllRegisterValues.
   // Again we ignore error if the regset is unsupported.
   uint32_t system_call = 0;
   DoWriteRegisterSet(NT_S390_SYSTEM_CALL, &system_call, 4);
@@ -420,7 +422,8 @@
   if (error.Fail())
     return error;
 
-  // Ignore errors if the regset is unsupported (happens on older kernels).
+  // Ignore errors if the regset is unsupported (happens on older
+  // kernels).
   DoWriteRegisterSet(NT_S390_SYSTEM_CALL, src, 4);
   src += 4;
 
Index: source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp
===================================================================
--- source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp
+++ source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp
@@ -212,7 +212,8 @@
 // Required ptrace defines.
 // ----------------------------------------------------------------------------
 
-// Support ptrace extensions even when compiled without required kernel support
+// Support ptrace extensions even when compiled without required kernel
+// support
 #ifndef NT_X86_XSTATE
 #define NT_X86_XSTATE 0x202
 #endif
@@ -220,8 +221,8 @@
 #define NT_PRXFPREG 0x46e62b7f
 #endif
 
-// On x86_64 NT_PRFPREG is used to access the FXSAVE area. On i386, we need to
-// use NT_PRXFPREG.
+// On x86_64 NT_PRFPREG is used to access the FXSAVE area. On i386, we
+// need to use NT_PRXFPREG.
 static inline unsigned int fxsr_regset(const ArchSpec &arch) {
   return arch.GetAddressByteSize() == 8 ? NT_PRFPREG : NT_PRXFPREG;
 }
@@ -230,7 +231,8 @@
 // Required MPX define.
 // ----------------------------------------------------------------------------
 
-// Support MPX extensions also if compiled with compiler without MPX support.
+// Support MPX extensions also if compiled with compiler without MPX
+// support.
 #ifndef bit_MPX
 #define bit_MPX 0x4000
 #endif
@@ -329,9 +331,9 @@
     break;
   }
 
-  // Initialize m_iovec to point to the buffer and buffer size
-  // using the conventions of Berkeley style UIO structures, as required
-  // by PTRACE extensions.
+  // Initialize m_iovec to point to the buffer and buffer size using the
+  // conventions of Berkeley style UIO structures, as required by PTRACE
+  // extensions.
   m_iovec.iov_base = &m_fpr;
   m_iovec.iov_len = sizeof(m_fpr);
 
@@ -343,8 +345,9 @@
   m_fctrl_offset_in_userarea = reg_info_fctrl->byte_offset;
 }
 
-// CONSIDER after local and llgs debugging are merged, register set support can
-// be moved into a base x86-64 class with IsRegisterSetAvailable made virtual.
+// CONSIDER after local and llgs debugging are merged, register set
+// support can be moved into a base x86-64 class with
+// IsRegisterSetAvailable made virtual.
 uint32_t NativeRegisterContextLinux_x86_64::GetRegisterSetCount() const {
   uint32_t sets = 0;
   for (uint32_t set_index = 0; set_index < k_num_register_sets; ++set_index) {
@@ -395,8 +398,8 @@
 
   const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
   if (reg == LLDB_INVALID_REGNUM) {
-    // This is likely an internal register for lldb use only and should not be
-    // directly queried.
+    // This is likely an internal register for lldb use only and should
+    // not be directly queried.
     error.SetErrorStringWithFormat("register \"%s\" is an internal-only lldb "
                                    "register, cannot read directly",
                                    reg_info->name);
@@ -420,14 +423,14 @@
     error = ReadRegisterRaw(full_reg, reg_value);
 
     if (error.Success()) {
-      // If our read was not aligned (for ah,bh,ch,dh), shift our returned value
-      // one byte to the right.
+      // If our read was not aligned (for ah,bh,ch,dh), shift our returned
+      // value one byte to the right.
       if (is_subreg && (reg_info->byte_offset & 0x1))
         reg_value.SetUInt64(reg_value.GetAsUInt64() >> 8);
 
-      // If our return byte size was greater than the return value reg size,
-      // then
-      // use the type specified by reg_info rather than the uint64_t default
+      // If our return byte size was greater than the return value reg
+      // size, then use the type specified by reg_info rather than the
+      // uint64_t default
       if (reg_value.GetByteSize() > reg_info->byte_size)
         reg_value.SetType(reg_info);
     }
@@ -448,7 +451,8 @@
         reg_value.SetBytes(m_fpr.fxsave.xmm[reg - m_reg_info.first_xmm].bytes,
                            reg_info->byte_size, byte_order);
       if (reg >= m_reg_info.first_ymm && reg <= m_reg_info.last_ymm) {
-        // Concatenate ymm using the register halves in xmm.bytes and ymmh.bytes
+        // Concatenate ymm using the register halves in xmm.bytes and
+        // ymmh.bytes
         if (CopyXSTATEtoYMM(reg, byte_order))
           reg_value.SetBytes(m_ymm_set.ymm[reg - m_reg_info.first_ymm].bytes,
                              reg_info->byte_size, byte_order);
@@ -489,12 +493,11 @@
 
   // Get pointer to m_fpr.fxsave variable and set the data from it.
 
-  // Byte offsets of all registers are calculated wrt 'UserArea' structure.
-  // However, ReadFPR() reads fpu registers {using ptrace(PTRACE_GETFPREGS,..)}
-  // and stores them in 'm_fpr' (of type FPR structure). To extract values of
-  // fpu
-  // registers, m_fpr should be read at byte offsets calculated wrt to FPR
-  // structure.
+  // Byte offsets of all registers are calculated wrt 'UserArea'
+  // structure. However, ReadFPR() reads fpu registers {using
+  // ptrace(PTRACE_GETFPREGS,..)} and stores them in 'm_fpr' (of type FPR
+  // structure). To extract values of fpu registers, m_fpr should be read
+  // at byte offsets calculated wrt to FPR structure.
 
   // Since, FPR structure is also one of the member of UserArea structure.
   // byte_offset(fpu wrt FPR) = byte_offset(fpu wrt UserArea) -
@@ -529,8 +532,8 @@
     uint32_t reg_index) {
   XSAVE_HDR::XFeature &xstate_bv = m_fpr.xsave.header.xstate_bv;
   if (IsFPR(reg_index)) {
-    // IsFPR considers both %st and %xmm registers as floating point, but these
-    // map to two features. Set both flags, just in case.
+    // IsFPR considers both %st and %xmm registers as floating point, but
+    // these map to two features. Set both flags, just in case.
     xstate_bv |= XSAVE_HDR::XFeature::FP | XSAVE_HDR::XFeature::SSE;
   } else if (IsAVX(reg_index)) {
     // Lower bytes of some %ymm registers are shared with %xmm registers.
@@ -572,8 +575,8 @@
 
       if (reg_index >= m_reg_info.first_ymm &&
           reg_index <= m_reg_info.last_ymm) {
-        // Store ymm register content, and split into the register halves in
-        // xmm.bytes and ymmh.bytes
+        // Store ymm register content, and split into the register halves
+        // in xmm.bytes and ymmh.bytes
         ::memcpy(m_ymm_set.ymm[reg_index - m_reg_info.first_ymm].bytes,
                  reg_value.GetBytes(), reg_value.GetByteSize());
         if (!CopyYMMtoXSTATE(reg_index, GetByteOrder()))
@@ -598,16 +601,15 @@
     } else {
       // Get pointer to m_fpr.fxsave variable and set the data to it.
 
-      // Byte offsets of all registers are calculated wrt 'UserArea' structure.
-      // However, WriteFPR() takes m_fpr (of type FPR structure) and writes only
-      // fpu
-      // registers using ptrace(PTRACE_SETFPREGS,..) API. Hence fpu registers
-      // should
-      // be written in m_fpr at byte offsets calculated wrt FPR structure.
+      // Byte offsets of all registers are calculated wrt 'UserArea'
+      // structure. However, WriteFPR() takes m_fpr (of type FPR
+      // structure) and writes only fpu registers using
+      // ptrace(PTRACE_SETFPREGS,..) API. Hence fpu registers should be
+      // written in m_fpr at byte offsets calculated wrt FPR structure.
 
-      // Since, FPR structure is also one of the member of UserArea structure.
-      // byte_offset(fpu wrt FPR) = byte_offset(fpu wrt UserArea) -
-      // byte_offset(fctrl wrt UserArea)
+      // Since, FPR structure is also one of the member of UserArea
+      // structure. byte_offset(fpu wrt FPR) = byte_offset(fpu wrt
+      // UserArea) - byte_offset(fctrl wrt UserArea)
       assert((reg_info->byte_offset - m_fctrl_offset_in_userarea) <
              sizeof(m_fpr));
       uint8_t *dst = (uint8_t *)&m_fpr + reg_info->byte_offset -
@@ -700,7 +702,8 @@
         }
       }
     }
-    // Copy the extended register state including the assembled ymm registers.
+    // Copy the extended register state including the assembled ymm
+    // registers.
     ::memcpy(dst, &m_fpr, sizeof(m_fpr));
   } else {
     assert(false && "how do we save the floating point registers?");
@@ -1068,10 +1071,9 @@
   if (wp_index >= NumSupportedHardwareWatchpoints())
     return Status("Watchpoint index out of range");
 
-  // Read only watchpoints aren't supported on x86_64. Fall back to read/write
-  // waitchpoints instead.
-  // TODO: Add logic to detect when a write happens and ignore that watchpoint
-  // hit.
+  // Read only watchpoints aren't supported on x86_64. Fall back to
+  // read/write waitchpoints instead. TODO: Add logic to detect when a
+  // write happens and ignore that watchpoint hit.
   if (watch_flags == 0x2)
     watch_flags = 0x3;
 
@@ -1093,8 +1095,7 @@
   if (error.Fail())
     return error;
 
-  // for watchpoints 0, 1, 2, or 3, respectively,
-  // set bits 1, 3, 5, or 7
+  // for watchpoints 0, 1, 2, or 3, respectively, set bits 1, 3, 5, or 7
   uint64_t enable_bit = 1 << (2 * wp_index);
 
   // set bits 16-17, 20-21, 24-25, or 28-29
@@ -1132,8 +1133,8 @@
 
   RegisterValue reg_value;
 
-  // for watchpoints 0, 1, 2, or 3, respectively,
-  // clear bits 0, 1, 2, or 3 of the debug status register (DR6)
+  // for watchpoints 0, 1, 2, or 3, respectively, clear bits 0, 1, 2, or 3
+  // of the debug status register (DR6)
   Status error = ReadRegisterRaw(m_reg_info.first_dr + 6, reg_value);
   if (error.Fail())
     return false;
@@ -1143,9 +1144,9 @@
   if (error.Fail())
     return false;
 
-  // for watchpoints 0, 1, 2, or 3, respectively,
-  // clear bits {0-1,16-19}, {2-3,20-23}, {4-5,24-27}, or {6-7,28-31}
-  // of the debug control register (DR7)
+  // for watchpoints 0, 1, 2, or 3, respectively, clear bits {0-1,16-19},
+  // {2-3,20-23}, {4-5,24-27}, or {6-7,28-31} of the debug control
+  // register (DR7)
   error = ReadRegisterRaw(m_reg_info.first_dr + 7, reg_value);
   if (error.Fail())
     return false;
Index: source/Plugins/Process/Linux/NativeThreadLinux.cpp
===================================================================
--- source/Plugins/Process/Linux/NativeThreadLinux.cpp
+++ source/Plugins/Process/Linux/NativeThreadLinux.cpp
@@ -211,8 +211,8 @@
   m_stop_info.reason = StopReason::eStopReasonNone;
   m_stop_description.clear();
 
-  // If watchpoints have been set, but none on this thread,
-  // then this is a new thread. So set all existing watchpoints.
+  // If watchpoints have been set, but none on this thread, then this is a
+  // new thread. So set all existing watchpoints.
   if (m_watchpoint_index_map.empty()) {
     NativeProcessLinux &process = GetProcess();
 
@@ -252,9 +252,10 @@
   m_stop_info.reason = StopReason::eStopReasonNone;
 
   if(!m_step_workaround) {
-    // If we already hava a workaround inplace, don't reset it. Otherwise, the
-    // destructor of the existing instance will run after the new instance has
-    // fetched the cpu mask, and the thread will end up with the wrong mask.
+    // If we already hava a workaround inplace, don't reset it. Otherwise,
+    // the destructor of the existing instance will run after the new
+    // instance has fetched the cpu mask, and the thread will end up with
+    // the wrong mask.
     m_step_workaround = SingleStepWorkaround::Get(m_tid);
   }
 
@@ -262,9 +263,9 @@
   if (signo != LLDB_INVALID_SIGNAL_NUMBER)
     data = signo;
 
-  // If hardware single-stepping is not supported, we just do a continue. The
-  // breakpoint on the
-  // next instruction has been setup in NativeProcessLinux::Resume.
+  // If hardware single-stepping is not supported, we just do a continue.
+  // The breakpoint on the next instruction has been setup in
+  // NativeProcessLinux::Resume.
   return NativeProcessLinux::PtraceWrapper(
       GetProcess().SupportHardwareSingleStepping() ? PTRACE_SINGLESTEP
                                                    : PTRACE_CONT,
@@ -290,8 +291,8 @@
     case SIGBUS:
     case SIGFPE:
     case SIGILL:
-      // In case of MIPS64 target, SI_KERNEL is generated for invalid 64bit
-      // address.
+      // In case of MIPS64 target, SI_KERNEL is generated for invalid
+      // 64bit address.
       const auto reason =
           (info->si_signo == SIGBUS && info->si_code == SI_KERNEL)
               ? CrashReason::eInvalidAddress
Index: source/Plugins/Process/Linux/SingleStepCheck.cpp
===================================================================
--- source/Plugins/Process/Linux/SingleStepCheck.cpp
+++ source/Plugins/Process/Linux/SingleStepCheck.cpp
@@ -33,15 +33,15 @@
   if (ptrace(PTRACE_TRACEME, 0, nullptr, nullptr) == -1)
     _exit(1);
 
-  // We just do an endless loop SIGSTOPPING ourselves until killed. The tracer
-  // will fiddle with our cpu affinities and monitor the behaviour.
+  // We just do an endless loop SIGSTOPPING ourselves until killed. The
+  // tracer will fiddle with our cpu affinities and monitor the behaviour.
   for (;;) {
     raise(SIGSTOP);
 
-    // Generate a bunch of instructions here, so that a single-step does not
-    // land in the raise() accidentally. If single-stepping works, we will be
-    // spinning in this loop. If it doesn't, we'll land in the raise() call
-    // above.
+    // Generate a bunch of instructions here, so that a single-step does
+    // not land in the raise() accidentally. If single-stepping works, we
+    // will be spinning in this loop. If it doesn't, we'll land in the
+    // raise() call above.
     for (volatile unsigned i = 0; i < CPU_SETSIZE; ++i)
       ;
   }
@@ -58,10 +58,10 @@
 };
 
 bool WorkaroundNeeded() {
-  // We shall spawn a child, and use it to verify the debug capabilities of the
-  // cpu. We shall iterate through the cpus, bind the child to each one in turn,
-  // and verify that single-stepping works on that cpu. A workaround is needed
-  // if we find at least one broken cpu.
+  // We shall spawn a child, and use it to verify the debug capabilities
+  // of the cpu. We shall iterate through the cpus, bind the child to each
+  // one in turn, and verify that single-stepping works on that cpu. A
+  // workaround is needed if we find at least one broken cpu.
 
   Log *log = ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD);
   ::pid_t child_pid = fork();
@@ -129,8 +129,8 @@
     LLDB_LOG(log,
              "SINGLE STEPPING ON FIRST CPU IS NOT WORKING. DEBUGGING "
              "LIKELY TO BE UNRELIABLE.");
-    // No point in trying to fiddle with the affinities, just give it our best
-    // shot and see how it goes.
+    // No point in trying to fiddle with the affinities, just give it our
+    // best shot and see how it goes.
     return false;
   }
 
@@ -160,9 +160,9 @@
   CPU_ZERO(&set);
   CPU_SET(0, &set);
   if (sched_setaffinity(tid, sizeof set, &set) != 0) {
-    // This may fail in very locked down systems, if the thread is not allowed
-    // to run on cpu 0. If that happens, only thing we can do is it log it and
-    // continue...
+    // This may fail in very locked down systems, if the thread is not
+    // allowed to run on cpu 0. If that happens, only thing we can do is
+    // it log it and continue...
     LLDB_LOG(log, "Unable to set cpu affinity for thread {0}: {1}", tid,
              Status(errno, eErrorTypePOSIX));
   }
Index: source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
===================================================================
--- source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
+++ source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
@@ -87,7 +87,8 @@
 
   std::lock_guard<std::recursive_mutex> guard(m_sequence_mutex);
 #ifdef LLDB_CONFIGURATION_DEBUG
-  // NOTE: this only works for packets that are in native endian byte order
+  // NOTE: this only works for packets that are in native endian byte
+  // order
   assert(request_packet.GetSize() ==
          *((const uint16_t *)(request_packet.GetData() + 2)));
 #endif
@@ -104,8 +105,8 @@
           const uint8_t reply_command = reply_packet.GetU8(&offset);
           const uint8_t reply_sequence_id = reply_packet.GetU8(&offset);
           if (request_sequence_id == reply_sequence_id) {
-            // The sequent ID was correct, now verify we got the response we
-            // were looking for
+            // The sequent ID was correct, now verify we got the response
+            // we were looking for
             if ((reply_command & eCommandTypeMask) == command) {
               // Success
               if (command == KDP_RESUMECPUS)
@@ -117,21 +118,19 @@
               return false;
             }
           } else if (reply_sequence_id > request_sequence_id) {
-            // Sequence ID was greater than the sequence ID of the packet we
-            // sent, something
-            // is really wrong...
+            // Sequence ID was greater than the sequence ID of the packet
+            // we sent, something is really wrong...
             reply_packet.Clear();
             return false;
           } else {
-            // The reply sequence ID was less than our current packet's sequence
-            // ID
-            // so we should keep trying to get a response because this was a
-            // response
-            // for a previous packet that we must have retried.
+            // The reply sequence ID was less than our current packet's
+            // sequence ID so we should keep trying to get a response
+            // because this was a response for a previous packet that we
+            // must have retried.
           }
         } else {
-          // Break and retry sending the packet as we didn't get a response due
-          // to timeout
+          // Break and retry sending the packet as we didn't get a
+          // response due to timeout
           break;
         }
       }
@@ -315,9 +314,9 @@
       offset = 2;
       const uint16_t length = packet.GetU16(&offset);
       if (length <= bytes_available) {
-        // We have an entire packet ready, we need to copy the data
-        // bytes into a buffer that will be owned by the packet and
-        // erase the bytes from our communcation buffer "m_bytes"
+        // We have an entire packet ready, we need to copy the data bytes
+        // into a buffer that will be owned by the packet and erase the
+        // bytes from our communcation buffer "m_bytes"
         packet.SetData(DataBufferSP(new DataBufferHeap(&m_bytes[0], length)));
         m_bytes.erase(0, length);
 
@@ -332,8 +331,8 @@
     } break;
 
     default:
-      // Unrecognized reply command byte, erase this byte and try to get back on
-      // track
+      // Unrecognized reply command byte, erase this byte and try to get
+      // back on track
       if (log)
         log->Printf("CommunicationKDP::%s: tossing junk byte: 0x%2.2x",
                     __FUNCTION__, (uint8_t)m_bytes[0]);
@@ -354,8 +353,8 @@
     greeting = "";
 
   const CommandType command = KDP_CONNECT;
-  // Length is 82 uint16_t and the length of the greeting C string with the
-  // terminating NULL
+  // Length is 82 uint16_t and the length of the greeting C string with
+  // the terminating NULL
   const uint32_t command_length = 8 + 2 + 2 + ::strlen(greeting) + 1;
   MakeRequestPacketHeader(command, request_packet, command_length);
   // Always send connect ports as little endian
@@ -1209,7 +1208,8 @@
         ::memcpy(dst, src, bytes_to_copy);
         error.Clear();
         // Return the number of bytes we could have returned regardless if
-        // we copied them or not, just so we know when things don't match up
+        // we copied them or not, just so we know when things don't match
+        // up
         return src_len;
       }
     }
Index: source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
===================================================================
--- source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
+++ source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
@@ -226,9 +226,9 @@
 Status ProcessKDP::DoConnectRemote(Stream *strm, llvm::StringRef remote_url) {
   Status error;
 
-  // Don't let any JIT happen when doing KDP as we can't allocate
-  // memory and we don't want to be mucking with threads that might
-  // already be handling exceptions
+  // Don't let any JIT happen when doing KDP as we can't allocate memory
+  // and we don't want to be mucking with threads that might already be
+  // handling exceptions
   SetCanJIT(false);
 
   if (remote_url.empty()) {
@@ -268,8 +268,8 @@
           // The host architecture
           GetHostArchitecture(kernel_arch);
           ArchSpec target_arch = target.GetArchitecture();
-          // Merge in any unspecified stuff into the target architecture in
-          // case the target arch isn't set at all or incompletely.
+          // Merge in any unspecified stuff into the target architecture
+          // in case the target arch isn't set at all or incompletely.
           target_arch.MergeFrom(kernel_arch);
           target.SetArchitecture(target_arch);
 
@@ -282,21 +282,22 @@
 
           if (m_comm.RemoteIsEFI()) {
             // Select an invalid plugin name for the dynamic loader so one
-            // doesn't get used
-            // since EFI does its own manual loading via python scripting
+            // doesn't get used since EFI does its own manual loading via
+            // python scripting
             static ConstString g_none_dynamic_loader("none");
             m_dyld_plugin_name = g_none_dynamic_loader;
 
             if (kernel_uuid.IsValid()) {
-              // If EFI passed in a UUID= try to lookup UUID
-              // The slide will not be provided. But the UUID
-              // lookup will be used to launch EFI debug scripts
-              // from the dSYM, that can load all of the symbols.
+              // If EFI passed in a UUID= try to lookup UUID The slide
+              // will not be provided. But the UUID lookup will be used to
+              // launch EFI debug scripts from the dSYM, that can load all
+              // of the symbols.
               ModuleSpec module_spec;
               module_spec.GetUUID() = kernel_uuid;
               module_spec.GetArchitecture() = target.GetArchitecture();
 
-              // Lookup UUID locally, before attempting dsymForUUID like action
+              // Lookup UUID locally, before attempting dsymForUUID like
+              // action
               module_spec.GetSymbolFileSpec() =
                   Symbols::LocateExecutableSymbolFile(module_spec);
               if (module_spec.GetSymbolFileSpec()) {
@@ -317,8 +318,8 @@
                   // Get the current target executable
                   ModuleSP exe_module_sp(target.GetExecutableModule());
 
-                  // Make sure you don't already have the right module loaded
-                  // and they will be uniqued
+                  // Make sure you don't already have the right module
+                  // loaded and they will be uniqued
                   if (exe_module_sp.get() != module_sp.get())
                     target.SetExecutableModule(module_sp, false);
                 }
@@ -443,8 +444,8 @@
                   StateAsCString(thread_resume_state));
     switch (thread_resume_state) {
     case eStateSuspended:
-      // Nothing to do here when a thread will stay suspended
-      // we just leave the CPU mask bit set to zero for the thread
+      // Nothing to do here when a thread will stay suspended we just
+      // leave the CPU mask bit set to zero for the thread
       if (log)
         log->Printf("ProcessKDP::DoResume() = suspended???");
       break;
@@ -506,8 +507,8 @@
 }
 
 lldb::ThreadSP ProcessKDP::GetKernelThread() {
-  // KDP only tells us about one thread/core. Any other threads will usually
-  // be the ones that are read from memory by the OS plug-ins.
+  // KDP only tells us about one thread/core. Any other threads will
+  // usually be the ones that are read from memory by the OS plug-ins.
 
   ThreadSP thread_sp(m_kernel_thread_wp.lock());
   if (!thread_sp) {
@@ -535,8 +536,8 @@
 }
 
 void ProcessKDP::RefreshStateAfterStop() {
-  // Let all threads recover from stopping and do any clean up based
-  // on the previous thread state (if any).
+  // Let all threads recover from stopping and do any clean up based on
+  // the previous thread state (if any).
   m_thread_list.RefreshStateAfterStop();
 }
 
@@ -546,8 +547,8 @@
   if (m_comm.IsRunning()) {
     if (m_destroy_in_process) {
       // If we are attemping to destroy, we need to not return an error to
-      // Halt or DoDestroy won't get called.
-      // We are also currently running, so send a process stopped event
+      // Halt or DoDestroy won't get called. We are also currently
+      // running, so send a process stopped event
       SetPrivateState(eStateStopped);
     } else {
       error.SetErrorString("KDP cannot interrupt a running kernel");
@@ -803,9 +804,9 @@
                       ") Got an event of type: %d...",
                       pid, event_type);
 
-        // When we are running, poll for 1 second to try and get an exception
-        // to indicate the process has stopped. If we don't get one, check to
-        // make sure no one asked us to exit
+        // When we are running, poll for 1 second to try and get an
+        // exception to indicate the process has stopped. If we don't get
+        // one, check to make sure no one asked us to exit
         bool is_running = false;
         DataExtractor exc_reply_packet;
         do {
@@ -828,9 +829,9 @@
               is_running = false;
               process->SetPrivateState(eStateStopped);
             } else {
-              // Check to see if we are supposed to exit. There is no way to
-              // interrupt a running kernel, so all we can do is wait for an
-              // exception or detach...
+              // Check to see if we are supposed to exit. There is no way
+              // to interrupt a running kernel, so all we can do is wait
+              // for an exception or detach...
               if (listener_sp->GetEvent(event_sp,
                                         std::chrono::microseconds(0))) {
                 // We got an event, go through the loop again
@@ -961,7 +962,8 @@
                   payload_bytes.size(), reply, error);
 
               if (error.Success()) {
-                // Copy the binary bytes into a hex ASCII string for the result
+                // Copy the binary bytes into a hex ASCII string for the
+                // result
                 StreamString packet;
                 packet.PutBytesAsRawHex8(
                     reply.GetDataStart(), reply.GetByteSize(),
Index: source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp
===================================================================
--- source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp
+++ source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp
@@ -59,14 +59,14 @@
 const char *ThreadKDP::GetQueueName() { return NULL; }
 
 void ThreadKDP::RefreshStateAfterStop() {
-  // Invalidate all registers in our register context. We don't set "force" to
-  // true because the stop reply packet might have had some register values
-  // that were expedited and these will already be copied into the register
-  // context by the time this function gets called. The KDPRegisterContext
-  // class has been made smart enough to detect when it needs to invalidate
-  // which registers are valid by putting hooks in the register read and
-  // register supply functions where they check the process stop ID and do
-  // the right thing.
+  // Invalidate all registers in our register context. We don't set
+  // "force" to true because the stop reply packet might have had some
+  // register values that were expedited and these will already be copied
+  // into the register context by the time this function gets called. The
+  // KDPRegisterContext class has been made smart enough to detect when it
+  // needs to invalidate which registers are valid by putting hooks in the
+  // register read and register supply functions where they check the
+  // process stop ID and do the right thing.
   const bool force = false;
   lldb::RegisterContextSP reg_ctx_sp(GetRegisterContext());
   if (reg_ctx_sp)
@@ -154,10 +154,11 @@
       // We have to make a copy of the stop info because the thread list
       // will iterate through the threads and clear all stop infos..
 
-      // Let the StopInfoMachException::CreateStopReasonWithMachException()
-      // function update the PC if needed as we might hit a software breakpoint
-      // and need to decrement the PC (i386 and x86_64 need this) and KDP
-      // doesn't do this for us.
+      // Let the
+      // StopInfoMachException::CreateStopReasonWithMachException()
+      // function update the PC if needed as we might hit a software
+      // breakpoint and need to decrement the PC (i386 and x86_64 need
+      // this) and KDP doesn't do this for us.
       const bool pc_already_adjusted = false;
       const bool adjust_pc_if_needed = true;
 
Index: source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp
===================================================================
--- source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp
+++ source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp
@@ -23,10 +23,9 @@
 #include "lldb/Target/Process.h"
 #include "llvm/Support/Errno.h"
 
-// System includes - They have to be included after framework includes because
-// they define some
-// macros which collide with variable names in other modules
-// clang-format off
+// System includes - They have to be included after framework includes
+// because they define some macros which collide with variable names in
+// other modules clang-format off
 #include <sys/types.h>
 #include <sys/ptrace.h>
 #include <sys/sysctl.h>
@@ -325,8 +324,8 @@
 
 Status NativeProcessNetBSD::GetSoftwareBreakpointPCOffset(
     uint32_t &actual_opcode_size) {
-  // FIXME put this behind a breakpoint protocol class that can be
-  // set per architecture.  Need ARM, MIPS support here.
+  // FIXME put this behind a breakpoint protocol class that can be set per
+  // architecture.  Need ARM, MIPS support here.
   static const uint8_t g_i386_opcode[] = {0xCC};
   switch (m_arch.GetMachine()) {
   case llvm::Triple::x86_64:
@@ -342,8 +341,8 @@
 NativeProcessNetBSD::FixupBreakpointPCAsNeeded(NativeThreadNetBSD &thread) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
   Status error;
-  // Find out the size of a breakpoint (might depend on where we are in the
-  // code).
+  // Find out the size of a breakpoint (might depend on where we are in
+  // the code).
   NativeRegisterContext& context = thread.GetRegisterContext();
   uint32_t breakpoint_size = 0;
   error = GetSoftwareBreakpointPCOffset(breakpoint_size);
@@ -352,8 +351,8 @@
     return error;
   } else
     LLDB_LOG(log, "breakpoint size: {0}", breakpoint_size);
-  // First try probing for a breakpoint at a software breakpoint location: PC
-  // - breakpoint size.
+  // First try probing for a breakpoint at a software breakpoint location:
+  // PC - breakpoint size.
   const lldb::addr_t initial_pc_addr =
       context.GetPCfromBreakpointLocation();
   lldb::addr_t breakpoint_addr = initial_pc_addr;
@@ -551,9 +550,9 @@
   }
 
   lldb::addr_t prev_base_address = 0;
-  // FIXME start by finding the last region that is <= target address using
-  // binary search.  Data is sorted.
-  // There can be a ton of regions on pthreads apps with lots of threads.
+  // FIXME start by finding the last region that is <= target address
+  // using binary search.  Data is sorted. There can be a ton of regions
+  // on pthreads apps with lots of threads.
   for (auto it = m_mem_region_cache.begin(); it != m_mem_region_cache.end();
        ++it) {
     MemoryRegionInfo &proc_entry_info = it->first;
@@ -574,7 +573,8 @@
       range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo);
       return error;
     } else if (proc_entry_info.GetRange().Contains(load_addr)) {
-      // The target address is within the memory region we're processing here.
+      // The target address is within the memory region we're processing
+      // here.
       range_info = proc_entry_info;
       return error;
     }
@@ -582,9 +582,8 @@
     // parsed.
   }
   // If we made it here, we didn't find an entry that contained the given
-  // address. Return the
-  // load_addr as start and the amount of bytes betwwen load address and the
-  // end of the memory as size.
+  // address. Return the load_addr as start and the amount of bytes
+  // betwwen load address and the end of the memory as size.
   range_info.GetRange().SetRangeBase(load_addr);
   range_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
   range_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
@@ -596,8 +595,8 @@
 
 Status NativeProcessNetBSD::PopulateMemoryRegionCache() {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
-  // If our cache is empty, pull the latest.  There should always be at least
-  // one memory region if memory region handling is supported.
+  // If our cache is empty, pull the latest.  There should always be at
+  // least one memory region if memory region handling is supported.
   if (!m_mem_region_cache.empty()) {
     LLDB_LOG(log, "reusing {0} cached memory region entries",
              m_mem_region_cache.size());
@@ -781,8 +780,8 @@
     return status;
 
   int wstatus;
-  // Need to use WALLSIG otherwise we receive an error with errno=ECHLD
-  // At this point we should have a thread stopped if waitpid succeeds.
+  // Need to use WALLSIG otherwise we receive an error with errno=ECHLD At
+  // this point we should have a thread stopped if waitpid succeeds.
   if ((wstatus = waitpid(m_pid, NULL, WALLSIG)) < 0)
     return Status(errno, eErrorTypePOSIX);
 
Index: source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD_x86_64.cpp
===================================================================
--- source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD_x86_64.cpp
+++ source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD_x86_64.cpp
@@ -172,8 +172,9 @@
                                   CreateRegisterInfoInterface(target_arch)),
       m_gpr_x86_64(), m_fpr_x86_64(), m_dbr_x86_64() {}
 
-// CONSIDER after local and llgs debugging are merged, register set support can
-// be moved into a base x86-64 class with IsRegisterSetAvailable made virtual.
+// CONSIDER after local and llgs debugging are merged, register set
+// support can be moved into a base x86-64 class with
+// IsRegisterSetAvailable made virtual.
 uint32_t NativeRegisterContextNetBSD_x86_64::GetRegisterSetCount() const {
   uint32_t sets = 0;
   for (uint32_t set_index = 0; set_index < k_num_register_sets; ++set_index) {
@@ -260,8 +261,8 @@
 
   const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
   if (reg == LLDB_INVALID_REGNUM) {
-    // This is likely an internal register for lldb use only and should not be
-    // directly queried.
+    // This is likely an internal register for lldb use only and should
+    // not be directly queried.
     error.SetErrorStringWithFormat("register \"%s\" is an internal-only lldb "
                                    "register, cannot read directly",
                                    reg_info->name);
@@ -270,16 +271,16 @@
 
   int set = GetSetForNativeRegNum(reg);
   if (set == -1) {
-    // This is likely an internal register for lldb use only and should not be
-    // directly queried.
+    // This is likely an internal register for lldb use only and should
+    // not be directly queried.
     error.SetErrorStringWithFormat("register \"%s\" is in unrecognized set",
                                    reg_info->name);
     return error;
   }
 
   if (ReadRegisterSet(set) != 0) {
-    // This is likely an internal register for lldb use only and should not be
-    // directly queried.
+    // This is likely an internal register for lldb use only and should
+    // not be directly queried.
     error.SetErrorStringWithFormat(
         "reading register set for register \"%s\" failed", reg_info->name);
     return error;
@@ -456,8 +457,8 @@
 
   const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
   if (reg == LLDB_INVALID_REGNUM) {
-    // This is likely an internal register for lldb use only and should not be
-    // directly queried.
+    // This is likely an internal register for lldb use only and should
+    // not be directly queried.
     error.SetErrorStringWithFormat("register \"%s\" is an internal-only lldb "
                                    "register, cannot read directly",
                                    reg_info->name);
@@ -466,16 +467,16 @@
 
   int set = GetSetForNativeRegNum(reg);
   if (set == -1) {
-    // This is likely an internal register for lldb use only and should not be
-    // directly queried.
+    // This is likely an internal register for lldb use only and should
+    // not be directly queried.
     error.SetErrorStringWithFormat("register \"%s\" is in unrecognized set",
                                    reg_info->name);
     return error;
   }
 
   if (ReadRegisterSet(set) != 0) {
-    // This is likely an internal register for lldb use only and should not be
-    // directly queried.
+    // This is likely an internal register for lldb use only and should
+    // not be directly queried.
     error.SetErrorStringWithFormat(
         "reading register set for register \"%s\" failed", reg_info->name);
     return error;
@@ -778,10 +779,9 @@
   if (wp_index >= NumSupportedHardwareWatchpoints())
     return Status("Watchpoint index out of range");
 
-  // Read only watchpoints aren't supported on x86_64. Fall back to read/write
-  // waitchpoints instead.
-  // TODO: Add logic to detect when a write happens and ignore that watchpoint
-  // hit.
+  // Read only watchpoints aren't supported on x86_64. Fall back to
+  // read/write waitchpoints instead. TODO: Add logic to detect when a
+  // write happens and ignore that watchpoint hit.
   if (watch_flags == 0x2)
     watch_flags = 0x3;
 
@@ -805,8 +805,7 @@
   if (error.Fail())
     return error;
 
-  // for watchpoints 0, 1, 2, or 3, respectively,
-  // set bits 1, 3, 5, or 7
+  // for watchpoints 0, 1, 2, or 3, respectively, set bits 1, 3, 5, or 7
   uint64_t enable_bit = 1 << (2 * wp_index);
 
   // set bits 16-17, 20-21, 24-25, or 28-29
@@ -845,8 +844,8 @@
 
   RegisterValue reg_value;
 
-  // for watchpoints 0, 1, 2, or 3, respectively,
-  // clear bits 0, 1, 2, or 3 of the debug status register (DR6)
+  // for watchpoints 0, 1, 2, or 3, respectively, clear bits 0, 1, 2, or 3
+  // of the debug status register (DR6)
   const RegisterInfo *const reg_info_dr6 =
       GetRegisterInfoAtIndex(lldb_dr6_x86_64);
   Status error = ReadRegister(reg_info_dr6, reg_value);
@@ -858,9 +857,9 @@
   if (error.Fail())
     return false;
 
-  // for watchpoints 0, 1, 2, or 3, respectively,
-  // clear bits {0-1,16-19}, {2-3,20-23}, {4-5,24-27}, or {6-7,28-31}
-  // of the debug control register (DR7)
+  // for watchpoints 0, 1, 2, or 3, respectively, clear bits {0-1,16-19},
+  // {2-3,20-23}, {4-5,24-27}, or {6-7,28-31} of the debug control
+  // register (DR7)
   const RegisterInfo *const reg_info_dr7 =
       GetRegisterInfoAtIndex(lldb_dr7_x86_64);
   error = ReadRegister(reg_info_dr7, reg_value);
Index: source/Plugins/Process/POSIX/CrashReason.cpp
===================================================================
--- source/Plugins/Process/POSIX/CrashReason.cpp
+++ source/Plugins/Process/POSIX/CrashReason.cpp
@@ -46,9 +46,8 @@
   switch (info.si_code) {
 #ifdef SI_KERNEL
   case SI_KERNEL:
-    // Some platforms will occasionally send nonstandard spurious SI_KERNEL
-    // codes.
-    // One way to get this is via unaligned SIMD loads.
+    // Some platforms will occasionally send nonstandard spurious
+    // SI_KERNEL codes. One way to get this is via unaligned SIMD loads.
     return CrashReason::eInvalidAddress; // for lack of anything better
 #endif
   case SEGV_MAPERR:
Index: source/Plugins/Process/Utility/DynamicRegisterInfo.cpp
===================================================================
--- source/Plugins/Process/Utility/DynamicRegisterInfo.cpp
+++ source/Plugins/Process/Utility/DynamicRegisterInfo.cpp
@@ -74,9 +74,9 @@
       return 0;
     }
 
-    // { 'name':'rcx'       , 'bitsize' :  64, 'offset' :  16, 'encoding':'uint'
-    // , 'format':'hex'         , 'set': 0, 'ehframe' : 2,
-    // 'dwarf' : 2, 'generic':'arg4', 'alt-name':'arg4', },
+    // { 'name':'rcx'       , 'bitsize' :  64, 'offset' :  16,
+    // 'encoding':'uint' , 'format':'hex'         , 'set': 0, 'ehframe' :
+    // 2, 'dwarf' : 2, 'generic':'arg4', 'alt-name':'arg4', },
     RegisterInfo reg_info;
     std::vector<uint32_t> value_regs;
     std::vector<uint32_t> invalidate_regs;
@@ -100,24 +100,21 @@
     const ByteOrder byte_order = arch.GetByteOrder();
 
     if (reg_info.byte_offset == UINT32_MAX) {
-      // No offset for this register, see if the register has a value expression
-      // which indicates this register is part of another register. Value
-      // expressions
-      // are things like "rax[31:0]" which state that the current register's
-      // value
-      // is in a concrete register "rax" in bits 31:0. If there is a value
-      // expression
-      // we can calculate the offset
+      // No offset for this register, see if the register has a value
+      // expression which indicates this register is part of another
+      // register. Value expressions are things like "rax[31:0]" which
+      // state that the current register's value is in a concrete register
+      // "rax" in bits 31:0. If there is a value expression we can
+      // calculate the offset
       bool success = false;
       llvm::StringRef slice_str;
       if (reg_info_dict->GetValueForKeyAsString("slice", slice_str, nullptr)) {
         // Slices use the following format:
         //  REGNAME[MSBIT:LSBIT]
-        // REGNAME - name of the register to grab a slice of
-        // MSBIT - the most significant bit at which the current register value
-        // starts at
-        // LSBIT - the least significant bit at which the current register value
-        // ends at
+        // REGNAME - name of the register to grab a slice of MSBIT - the
+        // most significant bit at which the current register value starts
+        // at LSBIT - the least significant bit at which the current
+        // register value ends at
         static RegularExpression g_bitfield_regex(
             llvm::StringRef("([A-Za-z_][A-Za-z0-9_]*)\\[([0-9]+):([0-9]+)\\]"));
         RegularExpression::Match regex_match(3);
@@ -186,14 +183,14 @@
                      lsbit);
             }
           } else {
-            // TODO: print error invalid slice string that doesn't follow the
-            // format
+            // TODO: print error invalid slice string that doesn't follow
+            // the format
             printf("error: failed to extract regex matches for parsing the "
                    "register bitfield regex\n");
           }
         } else {
-          // TODO: print error invalid slice string that doesn't follow the
-          // format
+          // TODO: print error invalid slice string that doesn't follow
+          // the format
           printf("error: failed to match against register bitfield regex\n");
         }
       } else {
@@ -221,8 +218,8 @@
                   m_invalidate_regs_map[i].push_back(
                       composite_reg_info->kinds[eRegisterKindLLDB]);
                 } else {
-                  // TODO: print error invalid slice string that doesn't follow
-                  // the format
+                  // TODO: print error invalid slice string that doesn't
+                  // follow the format
                   printf("error: failed to find composite register by name: "
                          "\"%s\"\n",
                          composite_reg_name.GetCString());
@@ -336,8 +333,8 @@
           "generic", reg_info.kinds[lldb::eRegisterKindGeneric],
           LLDB_INVALID_REGNUM);
 
-    // Check if this register invalidates any other register values when it is
-    // modified
+    // Check if this register invalidates any other register values when
+    // it is modified
     StructuredData::Array *invalidate_reg_list = nullptr;
     if (reg_info_dict->GetValueForKeyAsArray("invalidate-regs",
                                              invalidate_reg_list)) {
@@ -354,8 +351,8 @@
               m_invalidate_regs_map[i].push_back(
                   invalidate_reg_info->kinds[eRegisterKindLLDB]);
             } else {
-              // TODO: print error invalid slice string that doesn't follow the
-              // format
+              // TODO: print error invalid slice string that doesn't
+              // follow the format
               printf("error: failed to find a 'invalidate-regs' register for "
                      "\"%s\" while parsing register \"%s\"\n",
                      invalidate_reg_name.GetCString(), reg_info.name);
@@ -439,8 +436,8 @@
     m_sets[set].registers = m_set_reg_nums[set].data();
   }
 
-  // sort and unique all value registers and make sure each is terminated with
-  // LLDB_INVALID_REGNUM
+  // sort and unique all value registers and make sure each is terminated
+  // with LLDB_INVALID_REGNUM
 
   for (reg_to_regs_map::iterator pos = m_value_regs_map.begin(),
                                  end = m_value_regs_map.end();
@@ -490,9 +487,8 @@
     }
   }
 
-  // sort and unique all invalidate registers and make sure each is terminated
-  // with
-  // LLDB_INVALID_REGNUM
+  // sort and unique all invalidate registers and make sure each is
+  // terminated with LLDB_INVALID_REGNUM
   for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(),
                                  end = m_invalidate_regs_map.end();
        pos != end; ++pos) {
Index: source/Plugins/Process/Utility/InferiorCallPOSIX.cpp
===================================================================
--- source/Plugins/Process/Utility/InferiorCallPOSIX.cpp
+++ source/Plugins/Process/Utility/InferiorCallPOSIX.cpp
@@ -180,10 +180,9 @@
   return false;
 }
 
-// FIXME: This has nothing to do with Posix, it is just a convenience function
-// that calls a
-// function of the form "void * (*)(void)".  We should find a better place to
-// put this.
+// FIXME: This has nothing to do with Posix, it is just a convenience
+// function that calls a function of the form "void * (*)(void)".  We
+// should find a better place to put this.
 
 bool lldb_private::InferiorCall(Process *process, const Address *address,
                                 addr_t &returned_func, bool trap_exceptions) {
Index: source/Plugins/Process/Utility/RegisterContextDarwin_arm.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextDarwin_arm.cpp
+++ source/Plugins/Process/Utility/RegisterContextDarwin_arm.cpp
@@ -1515,14 +1515,16 @@
   // autodetect how many breakpoints are supported dynamically...
   static uint32_t g_num_supported_hw_breakpoints = UINT32_MAX;
   if (g_num_supported_hw_breakpoints == UINT32_MAX) {
-    // Set this to zero in case we can't tell if there are any HW breakpoints
+    // Set this to zero in case we can't tell if there are any HW
+    // breakpoints
     g_num_supported_hw_breakpoints = 0;
 
     uint32_t register_DBGDIDR;
 
     asm("mrc p14, 0, %0, c0, c0, 0" : "=r"(register_DBGDIDR));
     g_num_supported_hw_breakpoints = Bits32(register_DBGDIDR, 27, 24);
-    // Zero is reserved for the BRP count, so don't increment it if it is zero
+    // Zero is reserved for the BRP count, so don't increment it if it is
+    // zero
     if (g_num_supported_hw_breakpoints > 0)
       g_num_supported_hw_breakpoints++;
     //        if (log) log->Printf ("DBGDIDR=0x%8.8x (number BRP pairs = %u)",
@@ -1647,7 +1649,8 @@
   // autodetect how many watchpoints are supported dynamically...
   static uint32_t g_num_supported_hw_watchpoints = UINT32_MAX;
   if (g_num_supported_hw_watchpoints == UINT32_MAX) {
-    // Set this to zero in case we can't tell if there are any HW breakpoints
+    // Set this to zero in case we can't tell if there are any HW
+    // breakpoints
     g_num_supported_hw_watchpoints = 0;
 
     uint32_t register_DBGDIDR;
@@ -1685,10 +1688,10 @@
   if (size > 4)
     return LLDB_INVALID_INDEX32;
 
-  // We can only watch up to four bytes that follow a 4 byte aligned address
-  // per watchpoint register pair. Since we have at most so we can only watch
-  // until the next 4 byte boundary and we need to make sure we can properly
-  // encode this.
+  // We can only watch up to four bytes that follow a 4 byte aligned
+  // address per watchpoint register pair. Since we have at most so we can
+  // only watch until the next 4 byte boundary and we need to make sure we
+  // can properly encode this.
   uint32_t addr_word_offset = addr % 4;
   //    if (log) log->Printf
   //    ("RegisterContextDarwin_arm::EnableHardwareWatchpoint() -
Index: source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp
+++ source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp
@@ -76,7 +76,8 @@
    sizeof(RegisterContextDarwin_arm64::EXC))
 
 //-----------------------------------------------------------------------------
-// Include RegisterInfos_arm64 to declare our g_register_infos_arm64 structure.
+// Include RegisterInfos_arm64 to declare our g_register_infos_arm64
+// structure.
 //-----------------------------------------------------------------------------
 #define DECLARE_REGISTER_INFOS_ARM64_STRUCT
 #include "RegisterInfos_arm64.h"
@@ -961,10 +962,10 @@
   if (size > 4)
     return LLDB_INVALID_INDEX32;
 
-  // We can only watch up to four bytes that follow a 4 byte aligned address
-  // per watchpoint register pair. Since we have at most so we can only watch
-  // until the next 4 byte boundary and we need to make sure we can properly
-  // encode this.
+  // We can only watch up to four bytes that follow a 4 byte aligned
+  // address per watchpoint register pair. Since we have at most so we can
+  // only watch until the next 4 byte boundary and we need to make sure we
+  // can properly encode this.
   uint32_t addr_word_offset = addr % 4;
   //    if (log) log->Printf
   //    ("RegisterContextDarwin_arm64::EnableHardwareWatchpoint() -
Index: source/Plugins/Process/Utility/RegisterContextDarwin_i386.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextDarwin_i386.cpp
+++ source/Plugins/Process/Utility/RegisterContextDarwin_i386.cpp
@@ -146,10 +146,10 @@
    sizeof(RegisterContextDarwin_i386::GPR) +                                   \
    sizeof(RegisterContextDarwin_i386::FPU))
 
-// These macros will auto define the register name, alt name, register size,
-// register offset, encoding, format and native register. This ensures that
-// the register state structures are defined correctly and have the correct
-// sizes and offsets.
+// These macros will auto define the register name, alt name, register
+// size, register offset, encoding, format and native register. This
+// ensures that the register state structures are defined correctly and
+// have the correct sizes and offsets.
 #define DEFINE_GPR(reg, alt)                                                   \
   #reg, alt, sizeof(((RegisterContextDarwin_i386::GPR *) NULL)->reg),          \
                     GPR_OFFSET(reg), eEncodingUint, eFormatHex
@@ -695,8 +695,8 @@
   case fpu_xmm6:
   case fpu_xmm7:
     // These values don't fit into scalar types,
-    // RegisterContext::ReadRegisterBytes()
-    // must be used for these registers
+    // RegisterContext::ReadRegisterBytes() must be used for these
+    // registers
     //::memcpy (reg_value.value.vector.uint8, fpu.xmm[reg - fpu_xmm0].bytes,
     //16);
     return false;
@@ -799,8 +799,8 @@
   case fpu_stmm6:
   case fpu_stmm7:
     // These values don't fit into scalar types,
-    // RegisterContext::ReadRegisterBytes()
-    // must be used for these registers
+    // RegisterContext::ReadRegisterBytes() must be used for these
+    // registers
     ::memcpy(fpu.stmm[reg - fpu_stmm0].bytes, value.GetBytes(),
              value.GetByteSize());
     return false;
@@ -814,8 +814,8 @@
   case fpu_xmm6:
   case fpu_xmm7:
     // These values don't fit into scalar types,
-    // RegisterContext::ReadRegisterBytes()
-    // must be used for these registers
+    // RegisterContext::ReadRegisterBytes() must be used for these
+    // registers
     ::memcpy(fpu.xmm[reg - fpu_xmm0].bytes, value.GetBytes(),
              value.GetByteSize());
     return false;
Index: source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.cpp
+++ source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.cpp
@@ -164,10 +164,10 @@
    sizeof(RegisterContextDarwin_x86_64::GPR) +                                 \
    sizeof(RegisterContextDarwin_x86_64::FPU))
 
-// These macros will auto define the register name, alt name, register size,
-// register offset, encoding, format and native register. This ensures that
-// the register state structures are defined correctly and have the correct
-// sizes and offsets.
+// These macros will auto define the register name, alt name, register
+// size, register offset, encoding, format and native register. This
+// ensures that the register state structures are defined correctly and
+// have the correct sizes and offsets.
 #define DEFINE_GPR(reg, alt)                                                   \
   #reg, alt, sizeof(((RegisterContextDarwin_x86_64::GPR *) NULL)->reg),        \
                     GPR_OFFSET(reg), eEncodingUint, eFormatHex
Index: source/Plugins/Process/Utility/RegisterContextFreeBSD_i386.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextFreeBSD_i386.cpp
+++ source/Plugins/Process/Utility/RegisterContextFreeBSD_i386.cpp
@@ -55,7 +55,8 @@
 #define DR_OFFSET(reg_index) (LLVM_EXTENSION offsetof(dbreg, dr[reg_index]))
 
 //---------------------------------------------------------------------------
-// Include RegisterInfos_i386 to declare our g_register_infos_i386 structure.
+// Include RegisterInfos_i386 to declare our g_register_infos_i386
+// structure.
 //---------------------------------------------------------------------------
 #define DECLARE_REGISTER_INFOS_I386_STRUCT
 #include "RegisterInfos_i386.h"
Index: source/Plugins/Process/Utility/RegisterContextLLDB.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextLLDB.cpp
+++ source/Plugins/Process/Utility/RegisterContextLLDB.cpp
@@ -67,8 +67,8 @@
     InitializeNonZerothFrame();
   }
 
-  // This same code exists over in the GetFullUnwindPlanForFrame() but it may
-  // not have been executed yet
+  // This same code exists over in the GetFullUnwindPlanForFrame() but it
+  // may not have been executed yet
   if (IsFrameZero() || next_frame->m_frame_type == eTrapHandlerFrame ||
       next_frame->m_frame_type == eDebuggerFrame) {
     m_all_registers_available = true;
@@ -103,9 +103,8 @@
   return false;
 }
 
-// Initialize a RegisterContextLLDB which is the first frame of a stack -- the
-// zeroth frame or currently
-// executing frame.
+// Initialize a RegisterContextLLDB which is the first frame of a stack --
+// the zeroth frame or currently executing frame.
 
 void RegisterContextLLDB::InitializeZerothFrame() {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
@@ -128,28 +127,29 @@
 
   Process *process = exe_ctx.GetProcessPtr();
 
-  // Let ABIs fixup code addresses to make sure they are valid. In ARM ABIs
-  // this will strip bit zero in case we read a PC from memory or from the LR.
-  // (which would be a no-op in frame 0 where we get it from the register set,
-  // but still a good idea to make the call here for other ABIs that may exist.)
+  // Let ABIs fixup code addresses to make sure they are valid. In ARM
+  // ABIs this will strip bit zero in case we read a PC from memory or
+  // from the LR. (which would be a no-op in frame 0 where we get it from
+  // the register set, but still a good idea to make the call here for
+  // other ABIs that may exist.)
   ABI *abi = process->GetABI().get();
   if (abi)
     current_pc = abi->FixCodeAddress(current_pc);
 
-  // Initialize m_current_pc, an Address object, based on current_pc, an addr_t.
+  // Initialize m_current_pc, an Address object, based on current_pc, an
+  // addr_t.
   m_current_pc.SetLoadAddress(current_pc, &process->GetTarget());
 
   // If we don't have a Module for some reason, we're not going to find
-  // symbol/function information - just
-  // stick in some reasonable defaults and hope we can unwind past this frame.
+  // symbol/function information - just stick in some reasonable defaults
+  // and hope we can unwind past this frame.
   ModuleSP pc_module_sp(m_current_pc.GetModule());
   if (!m_current_pc.IsValid() || !pc_module_sp) {
     UnwindLogMsg("using architectural default unwind method");
   }
 
   // We require either a symbol or function in the symbols context to be
-  // successfully
-  // filled in or this context is of no use to us.
+  // successfully filled in or this context is of no use to us.
   const uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
   if (pc_module_sp.get() && (pc_module_sp->ResolveSymbolContextForAddress(
                                  m_current_pc, resolve_scope, m_sym_ctx) &
@@ -179,19 +179,18 @@
     m_frame_type = eNormalFrame;
   }
 
-  // If we were able to find a symbol/function, set addr_range to the bounds of
-  // that symbol/function.
-  // else treat the current pc value as the start_pc and record no offset.
+  // If we were able to find a symbol/function, set addr_range to the
+  // bounds of that symbol/function. else treat the current pc value as
+  // the start_pc and record no offset.
   if (addr_range.GetBaseAddress().IsValid()) {
     m_start_pc = addr_range.GetBaseAddress();
     if (m_current_pc.GetSection() == m_start_pc.GetSection()) {
       m_current_offset = m_current_pc.GetOffset() - m_start_pc.GetOffset();
     } else if (m_current_pc.GetModule() == m_start_pc.GetModule()) {
       // This means that whatever symbol we kicked up isn't really correct
-      // --- we should not cross section boundaries ... We really should NULL
-      // out
-      // the function/symbol in this case unless there is a bad assumption
-      // here due to inlined functions?
+      // --- we should not cross section boundaries ... We really should
+      // NULL out the function/symbol in this case unless there is a bad
+      // assumption here due to inlined functions?
       m_current_offset =
           m_current_pc.GetFileAddress() - m_start_pc.GetFileAddress();
     }
@@ -265,9 +264,9 @@
                m_full_unwind_plan_sp->GetSourceName().GetCString());
 }
 
-// Initialize a RegisterContextLLDB for the non-zeroth frame -- rely on the
-// RegisterContextLLDB "below" it
-// to provide things like its current pc value.
+// Initialize a RegisterContextLLDB for the non-zeroth frame -- rely on
+// the RegisterContextLLDB "below" it to provide things like its current
+// pc value.
 
 void RegisterContextLLDB::InitializeNonZerothFrame() {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
@@ -299,8 +298,9 @@
 
   ExecutionContext exe_ctx(m_thread.shared_from_this());
   Process *process = exe_ctx.GetProcessPtr();
-  // Let ABIs fixup code addresses to make sure they are valid. In ARM ABIs
-  // this will strip bit zero in case we read a PC from memory or from the LR.
+  // Let ABIs fixup code addresses to make sure they are valid. In ARM
+  // ABIs this will strip bit zero in case we read a PC from memory or
+  // from the LR.
   ABI *abi = process->GetABI().get();
   if (abi)
     pc = abi->FixCodeAddress(pc);
@@ -314,8 +314,8 @@
       UnwindLogMsg("sp = 0x%" PRIx64, reg_val);
   }
 
-  // A pc of 0x0 means it's the end of the stack crawl unless we're above a trap
-  // handler function
+  // A pc of 0x0 means it's the end of the stack crawl unless we're above
+  // a trap handler function
   bool above_trap_handler = false;
   if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
       GetNextFrame()->IsTrapHandlerFrame())
@@ -333,24 +333,22 @@
   m_current_pc.SetLoadAddress(pc, &process->GetTarget(), allow_section_end);
 
   // If we don't have a Module for some reason, we're not going to find
-  // symbol/function information - just
-  // stick in some reasonable defaults and hope we can unwind past this frame.
+  // symbol/function information - just stick in some reasonable defaults
+  // and hope we can unwind past this frame.
   ModuleSP pc_module_sp(m_current_pc.GetModule());
   if (!m_current_pc.IsValid() || !pc_module_sp) {
     UnwindLogMsg("using architectural default unwind method");
 
-    // Test the pc value to see if we know it's in an unmapped/non-executable
-    // region of memory.
+    // Test the pc value to see if we know it's in an unmapped/non-
+    // executable region of memory.
     uint32_t permissions;
     if (process->GetLoadAddressPermissions(pc, permissions) &&
         (permissions & ePermissionsExecutable) == 0) {
-      // If this is the second frame off the stack, we may have unwound the
-      // first frame
-      // incorrectly.  But using the architecture default unwind plan may get us
-      // back on
-      // track -- albeit possibly skipping a real frame.  Give this frame a
-      // clearly-invalid
-      // pc and see if we can get any further.
+      // If this is the second frame off the stack, we may have unwound
+      // the first frame incorrectly.  But using the architecture default
+      // unwind plan may get us back on track -- albeit possibly skipping
+      // a real frame.  Give this frame a clearly-invalid pc and see if we
+      // can get any further.
       if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
           GetNextFrame()->IsFrameZero()) {
         UnwindLogMsg("had a pc of 0x%" PRIx64 " which is not in executable "
@@ -359,8 +357,8 @@
                      (uint64_t)pc);
         m_frame_type = eSkipFrame;
       } else {
-        // anywhere other than the second frame, a non-executable pc means we're
-        // off in the weeds -- stop now.
+        // anywhere other than the second frame, a non-executable pc means
+        // we're off in the weeds -- stop now.
         m_frame_type = eNotAValidFrame;
         UnwindLogMsg("pc is in a non-executable section of memory and this "
                      "isn't the 2nd frame in the stack walk.");
@@ -398,9 +396,9 @@
           return;
         }
 
-        // m_cfa should point into the stack memory; if we can query memory
-        // region permissions,
-        // see if the memory is allocated & readable.
+        // m_cfa should point into the stack memory; if we can query
+        // memory region permissions, see if the memory is allocated &
+        // readable.
         if (process->GetLoadAddressPermissions(m_cfa, permissions) &&
             (permissions & ePermissionsReadable) == 0) {
           m_frame_type = eNotAValidFrame;
@@ -436,18 +434,17 @@
   bool resolve_tail_call_address = false; // m_current_pc can be one past the
                                           // address range of the function...
   // If the saved pc does not point to a function/symbol because it is
-  // beyond the bounds of the correct function and there's no symbol there,
-  // we do *not* want ResolveSymbolContextForAddress to back up the pc by 1,
-  // because then we might not find the correct unwind information later.
-  // Instead, let ResolveSymbolContextForAddress fail, and handle the case
-  // via decr_pc_and_recompute_addr_range below.
+  // beyond the bounds of the correct function and there's no symbol
+  // there, we do *not* want ResolveSymbolContextForAddress to back up the
+  // pc by 1, because then we might not find the correct unwind
+  // information later. Instead, let ResolveSymbolContextForAddress fail,
+  // and handle the case via decr_pc_and_recompute_addr_range below.
   const uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
   uint32_t resolved_scope = pc_module_sp->ResolveSymbolContextForAddress(
       m_current_pc, resolve_scope, m_sym_ctx, resolve_tail_call_address);
 
   // We require either a symbol or function in the symbols context to be
-  // successfully
-  // filled in or this context is of no use to us.
+  // successfully filled in or this context is of no use to us.
   if (resolve_scope & resolved_scope) {
     m_sym_ctx_valid = true;
   }
@@ -475,9 +472,9 @@
   if (m_sym_ctx_valid == false)
     decr_pc_and_recompute_addr_range = true;
 
-  // Or if we're in the middle of the stack (and not "above" an asynchronous
-  // event like sigtramp),
-  // and our "current" pc is the start of a function...
+  // Or if we're in the middle of the stack (and not "above" an
+  // asynchronous event like sigtramp), and our "current" pc is the start
+  // of a function...
   if (GetNextFrame()->m_frame_type != eTrapHandlerFrame &&
       GetNextFrame()->m_frame_type != eDebuggerFrame &&
       (!m_sym_ctx_valid ||
@@ -487,13 +484,11 @@
     decr_pc_and_recompute_addr_range = true;
   }
 
-  // We need to back up the pc by 1 byte and re-search for the Symbol to handle
-  // the case where the "saved pc"
-  // value is pointing to the next function, e.g. if a function ends with a CALL
-  // instruction.
-  // FIXME this may need to be an architectural-dependent behavior; if so we'll
-  // need to add a member function
-  // to the ABI plugin and consult that.
+  // We need to back up the pc by 1 byte and re-search for the Symbol to
+  // handle the case where the "saved pc" value is pointing to the next
+  // function, e.g. if a function ends with a CALL instruction. FIXME this
+  // may need to be an architectural-dependent behavior; if so we'll need
+  // to add a member function to the ABI plugin and consult that.
   if (decr_pc_and_recompute_addr_range) {
     UnwindLogMsg("Backing up the pc value of 0x%" PRIx64
                  " by 1 and re-doing symbol lookup; old symbol was %s",
@@ -516,9 +511,9 @@
                  GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
   }
 
-  // If we were able to find a symbol/function, set addr_range_ptr to the bounds
-  // of that symbol/function.
-  // else treat the current pc value as the start_pc and record no offset.
+  // If we were able to find a symbol/function, set addr_range_ptr to the
+  // bounds of that symbol/function. else treat the current pc value as
+  // the start_pc and record no offset.
   if (addr_range.GetBaseAddress().IsValid()) {
     m_start_pc = addr_range.GetBaseAddress();
     m_current_offset = pc - m_start_pc.GetLoadAddress(&process->GetTarget());
@@ -553,9 +548,8 @@
   RegisterKind row_register_kind = eRegisterKindGeneric;
 
   // Try to get by with just the fast UnwindPlan if possible - the full
-  // UnwindPlan may be expensive to get
-  // (e.g. if we have to parse the entire eh_frame section of an ObjectFile for
-  // the first time.)
+  // UnwindPlan may be expensive to get (e.g. if we have to parse the
+  // entire eh_frame section of an ObjectFile for the first time.)
 
   if (m_fast_unwind_plan_sp &&
       m_fast_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
@@ -615,20 +609,16 @@
 }
 
 bool RegisterContextLLDB::CheckIfLoopingStack() {
-  // If we have a bad stack setup, we can get the same CFA value multiple times
-  // -- or even
-  // more devious, we can actually oscillate between two CFA values. Detect that
-  // here and
-  // break out to avoid a possible infinite loop in lldb trying to unwind the
-  // stack.
-  // To detect when we have the same CFA value multiple times, we compare the
-  // CFA of the current
-  // frame with the 2nd next frame because in some specail case (e.g. signal
-  // hanlders, hand
-  // written assembly without ABI compiance) we can have 2 frames with the same
-  // CFA (in theory we
-  // can have arbitrary number of frames with the same CFA, but more then 2 is
-  // very very unlikely)
+  // If we have a bad stack setup, we can get the same CFA value multiple
+  // times -- or even more devious, we can actually oscillate between two
+  // CFA values. Detect that here and break out to avoid a possible
+  // infinite loop in lldb trying to unwind the stack. To detect when we
+  // have the same CFA value multiple times, we compare the CFA of the
+  // current frame with the 2nd next frame because in some specail case
+  // (e.g. signal hanlders, hand written assembly without ABI compiance)
+  // we can have 2 frames with the same CFA (in theory we can have
+  // arbitrary number of frames with the same CFA, but more then 2 is very
+  // very unlikely)
 
   RegisterContextLLDB::SharedPtr next_frame = GetNextFrame();
   if (next_frame) {
@@ -733,16 +723,14 @@
     m_all_registers_available = true;
   }
 
-  // If we've done a jmp 0x0 / bl 0x0 (called through a null function pointer)
-  // so the pc is 0x0
-  // in the zeroth frame, we need to use the "unwind at first instruction" arch
-  // default UnwindPlan
-  // Also, if this Process can report on memory region attributes, any
-  // non-executable region means
-  // we jumped through a bad function pointer - handle the same way as 0x0.
-  // Note, if we have a symbol context & a symbol, we don't want to follow this
-  // code path.  This is
-  // for jumping to memory regions without any information available.
+  // If we've done a jmp 0x0 / bl 0x0 (called through a null function
+  // pointer) so the pc is 0x0 in the zeroth frame, we need to use the
+  // "unwind at first instruction" arch default UnwindPlan Also, if this
+  // Process can report on memory region attributes, any non-executable
+  // region means we jumped through a bad function pointer - handle the
+  // same way as 0x0. Note, if we have a symbol context & a symbol, we
+  // don't want to follow this code path.  This is for jumping to memory
+  // regions without any information available.
 
   if ((!m_sym_ctx_valid ||
        (m_sym_ctx.function == NULL && m_sym_ctx.symbol == NULL)) &&
@@ -763,7 +751,8 @@
     }
   }
 
-  // No Module for the current pc, try using the architecture default unwind.
+  // No Module for the current pc, try using the architecture default
+  // unwind.
   ModuleSP pc_module_sp(m_current_pc.GetModule());
   if (!m_current_pc.IsValid() || !pc_module_sp ||
       pc_module_sp->GetObjectFile() == NULL) {
@@ -779,13 +768,11 @@
             .GetFuncUnwindersContainingAddress(m_current_pc, m_sym_ctx);
   }
 
-  // No FuncUnwinders available for this pc (stripped function symbols, lldb
-  // could not augment its
-  // function table with another source, like LC_FUNCTION_STARTS or eh_frame in
-  // ObjectFileMachO).
-  // See if eh_frame or the .ARM.exidx tables have unwind information for this
-  // address, else fall
-  // back to the architectural default unwind.
+  // No FuncUnwinders available for this pc (stripped function symbols,
+  // lldb could not augment its function table with another source, like
+  // LC_FUNCTION_STARTS or eh_frame in ObjectFileMachO). See if eh_frame
+  // or the .ARM.exidx tables have unwind information for this address,
+  // else fall back to the architectural default unwind.
   if (!func_unwinders_sp) {
     m_frame_type = eNormalFrame;
 
@@ -793,7 +780,8 @@
         !m_current_pc.IsValid())
       return arch_default_unwind_plan_sp;
 
-    // Even with -fomit-frame-pointer, we can try eh_frame to get back on track.
+    // Even with -fomit-frame-pointer, we can try eh_frame to get back on
+    // track.
     DWARFCallFrameInfo *eh_frame =
         pc_module_sp->GetObjectFile()->GetUnwindTable().GetEHFrameInfo();
     if (eh_frame) {
@@ -819,11 +807,10 @@
   }
 
   // If we're in _sigtramp(), unwinding past this frame requires special
-  // knowledge.  On Mac OS X this knowledge
-  // is properly encoded in the eh_frame section, so prefer that if available.
-  // On other platforms we may need to provide a platform-specific UnwindPlan
-  // which encodes the details of
-  // how to unwind out of sigtramp.
+  // knowledge.  On Mac OS X this knowledge is properly encoded in the
+  // eh_frame section, so prefer that if available. On other platforms we
+  // may need to provide a platform-specific UnwindPlan which encodes the
+  // details of how to unwind out of sigtramp.
   if (m_frame_type == eTrapHandlerFrame && process) {
     m_fast_unwind_plan_sp.reset();
     unwind_plan_sp = func_unwinders_sp->GetEHFrameUnwindPlan(
@@ -834,25 +821,20 @@
     }
   }
 
-  // Ask the DynamicLoader if the eh_frame CFI should be trusted in this frame
-  // even when it's frame zero
-  // This comes up if we have hand-written functions in a Module and
-  // hand-written eh_frame.  The assembly
-  // instruction inspection may fail and the eh_frame CFI were probably written
-  // with some care to do the
-  // right thing.  It'd be nice if there was a way to ask the eh_frame directly
-  // if it is asynchronous
-  // (can be trusted at every instruction point) or synchronous (the normal case
-  // - only at call sites).
-  // But there is not.
+  // Ask the DynamicLoader if the eh_frame CFI should be trusted in this
+  // frame even when it's frame zero This comes up if we have hand-written
+  // functions in a Module and hand-written eh_frame.  The assembly
+  // instruction inspection may fail and the eh_frame CFI were probably
+  // written with some care to do the right thing.  It'd be nice if there
+  // was a way to ask the eh_frame directly if it is asynchronous (can be
+  // trusted at every instruction point) or synchronous (the normal case -
+  // only at call sites). But there is not.
   if (process && process->GetDynamicLoader() &&
       process->GetDynamicLoader()->AlwaysRelyOnEHUnwindInfo(m_sym_ctx)) {
     // We must specifically call the GetEHFrameUnwindPlan() method here --
-    // normally we would
-    // call GetUnwindPlanAtCallSite() -- because CallSite may return an unwind
-    // plan sourced from
-    // either eh_frame (that's what we intend) or compact unwind (this won't
-    // work)
+    // normally we would call GetUnwindPlanAtCallSite() -- because
+    // CallSite may return an unwind plan sourced from either eh_frame
+    // (that's what we intend) or compact unwind (this won't work)
     unwind_plan_sp = func_unwinders_sp->GetEHFrameUnwindPlan(
         process->GetTarget(), m_current_offset_backed_up_one);
     if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
@@ -863,30 +845,25 @@
     }
   }
 
-  // Typically the NonCallSite UnwindPlan is the unwind created by inspecting
-  // the assembly language instructions
+  // Typically the NonCallSite UnwindPlan is the unwind created by
+  // inspecting the assembly language instructions
   if (behaves_like_zeroth_frame && process) {
     unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite(
         process->GetTarget(), m_thread, m_current_offset_backed_up_one);
     if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
       if (unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo) {
         // We probably have an UnwindPlan created by inspecting assembly
-        // instructions. The
-        // assembly profilers work really well with compiler-generated functions
-        // but hand-
-        // written assembly can be problematic. We set the eh_frame based unwind
-        // plan as our
-        // fallback unwind plan if instruction emulation doesn't work out even
-        // for non call
-        // sites if it is available and use the architecture default unwind plan
-        // if it is
-        // not available. The eh_frame unwind plan is more reliable even on non
-        // call sites
-        // then the architecture default plan and for hand written assembly code
-        // it is often
-        // written in a way that it valid at all location what helps in the most
-        // common
-        // cases when the instruction emulation fails.
+        // instructions. The assembly profilers work really well with
+        // compiler-generated functions but hand- written assembly can be
+        // problematic. We set the eh_frame based unwind plan as our
+        // fallback unwind plan if instruction emulation doesn't work out
+        // even for non call sites if it is available and use the
+        // architecture default unwind plan if it is not available. The
+        // eh_frame unwind plan is more reliable even on non call sites
+        // then the architecture default plan and for hand written
+        // assembly code it is often written in a way that it valid at all
+        // location what helps in the most common cases when the
+        // instruction emulation fails.
         UnwindPlanSP call_site_unwind_plan =
             func_unwinders_sp->GetUnwindPlanAtCallSite(
                 process->GetTarget(), m_current_offset_backed_up_one);
@@ -918,10 +895,9 @@
     return unwind_plan_sp;
   }
 
-  // We'd prefer to use an UnwindPlan intended for call sites when we're at a
-  // call site but if we've
-  // struck out on that, fall back to using the non-call-site assembly
-  // inspection UnwindPlan if possible.
+  // We'd prefer to use an UnwindPlan intended for call sites when we're
+  // at a call site but if we've struck out on that, fall back to using
+  // the non-call-site assembly inspection UnwindPlan if possible.
   if (process) {
     unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite(
         process->GetTarget(), m_thread, m_current_offset_backed_up_one);
@@ -929,20 +905,16 @@
   if (unwind_plan_sp &&
       unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo) {
     // We probably have an UnwindPlan created by inspecting assembly
-    // instructions. The assembly
-    // profilers work really well with compiler-generated functions but hand-
-    // written assembly
-    // can be problematic. We set the eh_frame based unwind plan as our fallback
-    // unwind plan if
-    // instruction emulation doesn't work out even for non call sites if it is
-    // available and use
-    // the architecture default unwind plan if it is not available. The eh_frame
-    // unwind plan is
-    // more reliable even on non call sites then the architecture default plan
-    // and for hand
-    // written assembly code it is often written in a way that it valid at all
-    // location what
-    // helps in the most common cases when the instruction emulation fails.
+    // instructions. The assembly profilers work really well with
+    // compiler-generated functions but hand- written assembly can be
+    // problematic. We set the eh_frame based unwind plan as our fallback
+    // unwind plan if instruction emulation doesn't work out even for non
+    // call sites if it is available and use the architecture default
+    // unwind plan if it is not available. The eh_frame unwind plan is
+    // more reliable even on non call sites then the architecture default
+    // plan and for hand written assembly code it is often written in a
+    // way that it valid at all location what helps in the most common
+    // cases when the instruction emulation fails.
     UnwindPlanSP call_site_unwind_plan =
         func_unwinders_sp->GetUnwindPlanAtCallSite(
             process->GetTarget(), m_current_offset_backed_up_one);
@@ -963,8 +935,8 @@
   }
 
   // If we're on the first instruction of a function, and we have an
-  // architectural default UnwindPlan
-  // for the initial instruction of a function, use that.
+  // architectural default UnwindPlan for the initial instruction of a
+  // function, use that.
   if (m_current_offset_backed_up_one == 0) {
     unwind_plan_sp =
         func_unwinders_sp->GetUnwindPlanArchitectureDefaultAtFunctionEntry(
@@ -976,8 +948,8 @@
     }
   }
 
-  // If nothing else, use the architectural default UnwindPlan and hope that
-  // does the job.
+  // If nothing else, use the architectural default UnwindPlan and hope
+  // that does the job.
   if (arch_default_unwind_plan_sp)
     UnwindLogMsgVerbose(
         "frame uses %s for full UnwindPlan",
@@ -1115,26 +1087,22 @@
 }
 
 // After the final stack frame in a stack walk we'll get one invalid
-// (eNotAValidFrame) stack frame --
-// one past the end of the stack walk.  But higher-level code will need to tell
-// the differnece between
-// "the unwind plan below this frame failed" versus "we successfully completed
-// the stack walk" so
-// this method helps to disambiguate that.
+// (eNotAValidFrame) stack frame -- one past the end of the stack walk.
+// But higher-level code will need to tell the differnece between "the
+// unwind plan below this frame failed" versus "we successfully completed
+// the stack walk" so this method helps to disambiguate that.
 
 bool RegisterContextLLDB::IsTrapHandlerFrame() const {
   return m_frame_type == eTrapHandlerFrame;
 }
 
-// A skip frame is a bogus frame on the stack -- but one where we're likely to
-// find a real frame farther
-// up the stack if we keep looking.  It's always the second frame in an unwind
-// (i.e. the first frame after
-// frame zero) where unwinding can be the trickiest.  Ideally we'll mark up this
-// frame in some way so the
-// user knows we're displaying bad data and we may have skipped one frame of
-// their real program in the
-// process of getting back on track.
+// A skip frame is a bogus frame on the stack -- but one where we're
+// likely to find a real frame farther up the stack if we keep looking.
+// It's always the second frame in an unwind (i.e. the first frame after
+// frame zero) where unwinding can be the trickiest.  Ideally we'll mark
+// up this frame in some way so the user knows we're displaying bad data
+// and we may have skipped one frame of their real program in the process
+// of getting back on track.
 
 bool RegisterContextLLDB::IsSkipFrame() const {
   return m_frame_type == eSkipFrame;
@@ -1166,8 +1134,8 @@
   return false;
 }
 
-// Answer the question: Where did THIS frame save the CALLER frame ("previous"
-// frame)'s register value?
+// Answer the question: Where did THIS frame save the CALLER frame
+// ("previous" frame)'s register value?
 
 enum UnwindLLDB::RegisterSearchResult
 RegisterContextLLDB::SavedLocationForRegister(
@@ -1215,8 +1183,8 @@
   }
 
   if (!have_unwindplan_regloc) {
-    // m_full_unwind_plan_sp being NULL means that we haven't tried to find a
-    // full UnwindPlan yet
+    // m_full_unwind_plan_sp being NULL means that we haven't tried to
+    // find a full UnwindPlan yet
     if (!m_full_unwind_plan_sp)
       m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
 
@@ -1231,8 +1199,8 @@
       RegisterNumber return_address_reg;
 
       // If we're fetching the saved pc and this UnwindPlan defines a
-      // ReturnAddress register (e.g. lr on arm),
-      // look for the return address register number in the UnwindPlan's row.
+      // ReturnAddress register (e.g. lr on arm), look for the return
+      // address register number in the UnwindPlan's row.
       if (pc_regnum.IsValid() && pc_regnum == regnum &&
           m_full_unwind_plan_sp->GetReturnAddressRegister() !=
               LLDB_INVALID_REGNUM) {
@@ -1271,11 +1239,10 @@
             m_full_unwind_plan_sp->GetSourceName().GetCString());
       }
 
-      // This is frame 0 and we're retrieving the PC and it's saved in a Return
-      // Address register and
-      // it hasn't been saved anywhere yet -- that is, it's still live in the
-      // actual register.
-      // Handle this specially.
+      // This is frame 0 and we're retrieving the PC and it's saved in a
+      // Return Address register and it hasn't been saved anywhere yet --
+      // that is, it's still live in the actual register. Handle this
+      // specially.
 
       if (have_unwindplan_regloc == false && return_address_reg.IsValid() &&
           IsFrameZero()) {
@@ -1298,25 +1265,22 @@
       }
 
       // If this architecture stores the return address in a register (it
-      // defines a Return Address register)
-      // and we're on a non-zero stack frame and the Full UnwindPlan says that
-      // the pc is stored in the
-      // RA registers (e.g. lr on arm), then we know that the full unwindplan is
-      // not trustworthy -- this
-      // is an impossible situation and the instruction emulation code has
-      // likely been misled.
-      // If this stack frame meets those criteria, we need to throw away the
-      // Full UnwindPlan that the
-      // instruction emulation came up with and fall back to the architecture's
-      // Default UnwindPlan so
-      // the stack walk can get past this point.
-
-      // Special note:  If the Full UnwindPlan was generated from the compiler,
-      // don't second-guess it
-      // when we're at a call site location.
-
-      // arch_default_ra_regnum is the return address register # in the Full
-      // UnwindPlan register numbering
+      // defines a Return Address register) and we're on a non-zero stack
+      // frame and the Full UnwindPlan says that the pc is stored in the
+      // RA registers (e.g. lr on arm), then we know that the full
+      // unwindplan is not trustworthy -- this is an impossible situation
+      // and the instruction emulation code has likely been misled. If
+      // this stack frame meets those criteria, we need to throw away the
+      // Full UnwindPlan that the instruction emulation came up with and
+      // fall back to the architecture's Default UnwindPlan so the stack
+      // walk can get past this point.
+
+      // Special note:  If the Full UnwindPlan was generated from the
+      // compiler, don't second-guess it when we're at a call site
+      // location.
+
+      // arch_default_ra_regnum is the return address register # in the
+      // Full UnwindPlan register numbering
       RegisterNumber arch_default_ra_regnum(m_thread, eRegisterKindGeneric,
                                             LLDB_REGNUM_GENERIC_RA);
 
@@ -1331,15 +1295,16 @@
                      "register but this is a non-zero frame",
                      m_full_unwind_plan_sp->GetSourceName().GetCString());
 
-        // Throw away the full unwindplan; install the arch default unwindplan
+        // Throw away the full unwindplan; install the arch default
+        // unwindplan
         if (ForceSwitchToFallbackUnwindPlan()) {
           // Update for the possibly new unwind plan
           unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind();
           UnwindPlan::RowSP active_row =
               m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
 
-          // Sanity check: Verify that we can fetch a pc value and CFA value
-          // with this unwind plan
+          // Sanity check: Verify that we can fetch a pc value and CFA
+          // value with this unwind plan
 
           RegisterNumber arch_default_pc_reg(m_thread, eRegisterKindGeneric,
                                              LLDB_REGNUM_GENERIC_PC);
@@ -1376,11 +1341,11 @@
   ExecutionContext exe_ctx(m_thread.shared_from_this());
   Process *process = exe_ctx.GetProcessPtr();
   if (have_unwindplan_regloc == false) {
-    // If the UnwindPlan failed to give us an unwind location for this register,
-    // we may be able to fall back
-    // to some ABI-defined default.  For example, some ABIs allow to determine
-    // the caller's SP via the CFA.
-    // Also, the ABI may set volatile registers to the undefined state.
+    // If the UnwindPlan failed to give us an unwind location for this
+    // register, we may be able to fall back to some ABI-defined default.
+    // For example, some ABIs allow to determine the caller's SP via the
+    // CFA. Also, the ABI may set volatile registers to the undefined
+    // state.
     ABI *abi = process ? process->GetABI().get() : NULL;
     if (abi) {
       const RegisterInfo *reg_info =
@@ -1397,8 +1362,8 @@
 
   if (have_unwindplan_regloc == false) {
     if (IsFrameZero()) {
-      // This is frame 0 - we should return the actual live register context
-      // value
+      // This is frame 0 - we should return the actual live register
+      // context value
       lldb_private::UnwindLLDB::RegisterLocation new_regloc;
       new_regloc.type =
           UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext;
@@ -1423,7 +1388,8 @@
     return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
   }
 
-  // unwindplan_regloc has valid contents about where to retrieve the register
+  // unwindplan_regloc has valid contents about where to retrieve the
+  // register
   if (unwindplan_regloc.IsUnspecified()) {
     lldb_private::UnwindLLDB::RegisterLocation new_regloc;
     new_regloc.type = UnwindLLDB::RegisterLocation::eRegisterNotSaved;
@@ -1549,33 +1515,28 @@
   UnwindLogMsg("no save location for %s (%d) in this stack frame",
                regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
 
-  // FIXME UnwindPlan::Row types atDWARFExpression and isDWARFExpression are
-  // unsupported.
+  // FIXME UnwindPlan::Row types atDWARFExpression and isDWARFExpression
+  // are unsupported.
 
   return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
 }
 
 // TryFallbackUnwindPlan() -- this method is a little tricky.
 //
-// When this is called, the frame above -- the caller frame, the "previous"
-// frame --
-// is invalid or bad.
+// When this is called, the frame above -- the caller frame, the
+// "previous" frame -- is invalid or bad.
 //
-// Instead of stopping the stack walk here, we'll try a different UnwindPlan and
-// see
-// if we can get a valid frame above us.
+// Instead of stopping the stack walk here, we'll try a different
+// UnwindPlan and see if we can get a valid frame above us.
 //
-// This most often happens when an unwind plan based on assembly instruction
-// inspection
-// is not correct -- mostly with hand-written assembly functions or functions
-// where the
-// stack frame is set up "out of band", e.g. the kernel saved the register
-// context and
-// then called an asynchronous trap handler like _sigtramp.
+// This most often happens when an unwind plan based on assembly
+// instruction inspection is not correct -- mostly with hand-written
+// assembly functions or functions where the stack frame is set up "out of
+// band", e.g. the kernel saved the register context and then called an
+// asynchronous trap handler like _sigtramp.
 //
-// Often in these cases, if we just do a dumb stack walk we'll get past this
-// tricky
-// frame and our usual techniques can continue to be used.
+// Often in these cases, if we just do a dumb stack walk we'll get past
+// this tricky frame and our usual techniques can continue to be used.
 
 bool RegisterContextLLDB::TryFallbackUnwindPlan() {
   if (m_fallback_unwind_plan_sp.get() == nullptr)
@@ -1591,15 +1552,13 @@
   }
 
   // If a compiler generated unwind plan failed, trying the arch default
-  // unwindplan
-  // isn't going to do any better.
+  // unwindplan isn't going to do any better.
   if (m_full_unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes)
     return false;
 
-  // Get the caller's pc value and our own CFA value.
-  // Swap in the fallback unwind plan, re-fetch the caller's pc value and CFA
-  // value.
-  // If they're the same, then the fallback unwind plan provides no benefit.
+  // Get the caller's pc value and our own CFA value. Swap in the fallback
+  // unwind plan, re-fetch the caller's pc value and CFA value. If they're
+  // the same, then the fallback unwind plan provides no benefit.
 
   RegisterNumber pc_regnum(m_thread, eRegisterKindGeneric,
                            LLDB_REGNUM_GENERIC_PC);
@@ -1621,24 +1580,20 @@
     }
   }
 
-  // This is a tricky wrinkle!  If SavedLocationForRegister() detects a really
-  // impossible
-  // register location for the full unwind plan, it may call
-  // ForceSwitchToFallbackUnwindPlan()
-  // which in turn replaces the full unwindplan with the fallback... in short,
-  // we're done,
-  // we're using the fallback UnwindPlan.
-  // We checked if m_fallback_unwind_plan_sp was nullptr at the top -- the only
-  // way it
+  // This is a tricky wrinkle!  If SavedLocationForRegister() detects a
+  // really impossible register location for the full unwind plan, it may
+  // call ForceSwitchToFallbackUnwindPlan() which in turn replaces the
+  // full unwindplan with the fallback... in short, we're done, we're
+  // using the fallback UnwindPlan. We checked if
+  // m_fallback_unwind_plan_sp was nullptr at the top -- the only way it
   // became nullptr since then is via SavedLocationForRegister().
   if (m_fallback_unwind_plan_sp.get() == nullptr)
     return true;
 
-  // Switch the full UnwindPlan to be the fallback UnwindPlan.  If we decide
-  // this isn't
-  // working, we need to restore.
-  // We'll also need to save & restore the value of the m_cfa ivar.  Save is
-  // down below a bit in 'old_cfa'.
+  // Switch the full UnwindPlan to be the fallback UnwindPlan.  If we
+  // decide this isn't working, we need to restore. We'll also need to
+  // save & restore the value of the m_cfa ivar.  Save is down below a bit
+  // in 'old_cfa'.
   UnwindPlanSP original_full_unwind_plan_sp = m_full_unwind_plan_sp;
   addr_t old_cfa = m_cfa;
 
@@ -1845,9 +1800,8 @@
   return false;
 }
 
-// Retrieve a general purpose register value for THIS frame, as saved by the
-// NEXT frame, i.e. the frame that
-// this frame called.  e.g.
+// Retrieve a general purpose register value for THIS frame, as saved by
+// the NEXT frame, i.e. the frame that this frame called.  e.g.
 //
 //  foo () { }
 //  bar () { foo (); }
@@ -2034,7 +1988,8 @@
   return true;
 }
 
-// Retrieve the current pc value for THIS frame, as saved by the NEXT frame.
+// Retrieve the current pc value for THIS frame, as saved by the NEXT
+// frame.
 
 bool RegisterContextLLDB::ReadPC(addr_t &pc) {
   if (!IsValid())
@@ -2047,12 +2002,10 @@
 
   if (ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, pc)) {
     // A pc value of 0 or 1 is impossible in the middle of the stack -- it
-    // indicates the end of a stack walk.
-    // On the currently executing frame (or such a frame interrupted
-    // asynchronously by sigtramp et al) this may
-    // occur if code has jumped through a NULL pointer -- we want to be able to
-    // unwind past that frame to help
-    // find the bug.
+    // indicates the end of a stack walk. On the currently executing frame
+    // (or such a frame interrupted asynchronously by sigtramp et al) this
+    // may occur if code has jumped through a NULL pointer -- we want to
+    // be able to unwind past that frame to help find the bug.
 
     ProcessSP process_sp (m_thread.GetProcess());
     if (process_sp)
Index: source/Plugins/Process/Utility/RegisterContextLinux_i386.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextLinux_i386.cpp
+++ source/Plugins/Process/Utility/RegisterContextLinux_i386.cpp
@@ -83,7 +83,8 @@
 #define FPR_SIZE(reg) sizeof(((FPR_i386 *)NULL)->reg)
 
 //---------------------------------------------------------------------------
-// Include RegisterInfos_i386 to declare our g_register_infos_i386 structure.
+// Include RegisterInfos_i386 to declare our g_register_infos_i386
+// structure.
 //---------------------------------------------------------------------------
 #define DECLARE_REGISTER_INFOS_I386_STRUCT
 #include "RegisterInfos_i386.h"
Index: source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp
+++ source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp
@@ -23,7 +23,8 @@
 using namespace lldb;
 
 //---------------------------------------------------------------------------
-// Include RegisterInfos_mips to declare our g_register_infos_mips structure.
+// Include RegisterInfos_mips to declare our g_register_infos_mips
+// structure.
 //---------------------------------------------------------------------------
 #define DECLARE_REGISTER_INFOS_MIPS_STRUCT
 #include "RegisterInfos_mips.h"
Index: source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp
+++ source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp
@@ -34,7 +34,8 @@
 #undef DECLARE_REGISTER_INFOS_MIPS64_STRUCT
 
 //---------------------------------------------------------------------------
-// Include RegisterInfos_mips to declare our g_register_infos_mips structure.
+// Include RegisterInfos_mips to declare our g_register_infos_mips
+// structure.
 //---------------------------------------------------------------------------
 #define DECLARE_REGISTER_INFOS_MIPS_STRUCT
 #include "RegisterInfos_mips.h"
Index: source/Plugins/Process/Utility/RegisterContextLinux_s390x.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextLinux_s390x.cpp
+++ source/Plugins/Process/Utility/RegisterContextLinux_s390x.cpp
@@ -14,7 +14,8 @@
 using namespace lldb;
 
 //---------------------------------------------------------------------------
-// Include RegisterInfos_s390x to declare our g_register_infos_s390x structure.
+// Include RegisterInfos_s390x to declare our g_register_infos_s390x
+// structure.
 //---------------------------------------------------------------------------
 #define DECLARE_REGISTER_INFOS_S390X_STRUCT
 #include "RegisterInfos_s390x.h"
Index: source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp
+++ source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp
@@ -116,8 +116,8 @@
       }
       break;
 
-// TOOD: need a better way to detect when "long double" types are
-// the same bytes size as "double"
+// TOOD: need a better way to detect when "long double" types are the same
+// bytes size as "double"
 #if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__) &&       \
     !defined(_MSC_VER) && !defined(__mips__) && !defined(__powerpc__) &&       \
     !defined(__ANDROID__)
@@ -139,25 +139,26 @@
 
 bool RegisterContextMacOSXFrameBackchain::WriteRegister(
     const RegisterInfo *reg_info, const RegisterValue &value) {
-  // Not supported yet. We could easily add support for this by remembering
-  // the address of each entry (it would need to be part of the cursor)
+  // Not supported yet. We could easily add support for this by
+  // remembering the address of each entry (it would need to be part of
+  // the cursor)
   return false;
 }
 
 bool RegisterContextMacOSXFrameBackchain::ReadAllRegisterValues(
     lldb::DataBufferSP &data_sp) {
-  // libunwind frames can't handle this it doesn't always have all register
-  // values. This call should only be called on frame zero anyway so there
-  // shouldn't be any problem
+  // libunwind frames can't handle this it doesn't always have all
+  // register values. This call should only be called on frame zero anyway
+  // so there shouldn't be any problem
   return false;
 }
 
 bool RegisterContextMacOSXFrameBackchain::WriteAllRegisterValues(
     const lldb::DataBufferSP &data_sp) {
-  // Since this class doesn't respond to "ReadAllRegisterValues()", it must
-  // not have been the one that saved all the register values. So we just let
-  // the thread's register context (the register context for frame zero) do
-  // the writing.
+  // Since this class doesn't respond to "ReadAllRegisterValues()", it
+  // must not have been the one that saved all the register values. So we
+  // just let the thread's register context (the register context for
+  // frame zero) do the writing.
   return m_thread.GetRegisterContext()->WriteAllRegisterValues(data_sp);
 }
 
Index: source/Plugins/Process/Utility/RegisterContextMemory.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextMemory.cpp
+++ source/Plugins/Process/Utility/RegisterContextMemory.cpp
@@ -32,9 +32,9 @@
                                              addr_t reg_data_addr)
     : RegisterContext(thread, concrete_frame_idx), m_reg_infos(reg_infos),
       m_reg_valid(), m_reg_data(), m_reg_data_addr(reg_data_addr) {
-  // Resize our vector of bools to contain one bool for every register.
-  // We will use these boolean values to know when a register value
-  // is valid in m_reg_data.
+  // Resize our vector of bools to contain one bool for every register. We
+  // will use these boolean values to know when a register value is valid
+  // in m_reg_data.
   const size_t num_regs = reg_infos.GetNumRegisters();
   assert(num_regs > 0);
   m_reg_valid.resize(num_regs);
Index: source/Plugins/Process/Utility/RegisterContextOpenBSD_i386.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextOpenBSD_i386.cpp
+++ source/Plugins/Process/Utility/RegisterContextOpenBSD_i386.cpp
@@ -52,7 +52,8 @@
 #define DR_OFFSET(reg_index) (LLVM_EXTENSION offsetof(dbreg, dr[reg_index]))
 
 //---------------------------------------------------------------------------
-// Include RegisterInfos_i386 to declare our g_register_infos_i386 structure.
+// Include RegisterInfos_i386 to declare our g_register_infos_i386
+// structure.
 //---------------------------------------------------------------------------
 #define DECLARE_REGISTER_INFOS_I386_STRUCT
 #include "RegisterInfos_i386.h"
Index: source/Plugins/Process/Utility/RegisterContextPOSIX_arm.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextPOSIX_arm.cpp
+++ source/Plugins/Process/Utility/RegisterContextPOSIX_arm.cpp
@@ -141,9 +141,9 @@
 }
 
 const lldb_private::RegisterInfo *RegisterContextPOSIX_arm::GetRegisterInfo() {
-  // Commonly, this method is overridden and g_register_infos is copied and
-  // specialized.
-  // So, use GetRegisterInfo() rather than g_register_infos in this scope.
+  // Commonly, this method is overridden and g_register_infos is copied
+  // and specialized. So, use GetRegisterInfo() rather than
+  // g_register_infos in this scope.
   return m_register_info_ap->GetRegisterInfo();
 }
 
@@ -185,8 +185,8 @@
 }
 
 lldb::ByteOrder RegisterContextPOSIX_arm::GetByteOrder() {
-  // Get the target process whose privileged thread was used for the register
-  // read.
+  // Get the target process whose privileged thread was used for the
+  // register read.
   lldb::ByteOrder byte_order = lldb::eByteOrderInvalid;
   lldb_private::Process *process = CalculateProcess().get();
 
@@ -199,8 +199,8 @@
   return set_index < k_num_register_sets;
 }
 
-// Used when parsing DWARF and EH frame information and any other
-// object file sections that contain register numbers in them.
+// Used when parsing DWARF and EH frame information and any other object
+// file sections that contain register numbers in them.
 uint32_t RegisterContextPOSIX_arm::ConvertRegisterKindToRegisterNumber(
     lldb::RegisterKind kind, uint32_t num) {
   const uint32_t num_regs = GetRegisterCount();
Index: source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.cpp
+++ source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.cpp
@@ -161,9 +161,9 @@
 
 const lldb_private::RegisterInfo *
 RegisterContextPOSIX_arm64::GetRegisterInfo() {
-  // Commonly, this method is overridden and g_register_infos is copied and
-  // specialized.
-  // So, use GetRegisterInfo() rather than g_register_infos in this scope.
+  // Commonly, this method is overridden and g_register_infos is copied
+  // and specialized. So, use GetRegisterInfo() rather than
+  // g_register_infos in this scope.
   return m_register_info_ap->GetRegisterInfo();
 }
 
@@ -205,8 +205,8 @@
 }
 
 lldb::ByteOrder RegisterContextPOSIX_arm64::GetByteOrder() {
-  // Get the target process whose privileged thread was used for the register
-  // read.
+  // Get the target process whose privileged thread was used for the
+  // register read.
   lldb::ByteOrder byte_order = lldb::eByteOrderInvalid;
   lldb_private::Process *process = CalculateProcess().get();
 
@@ -219,8 +219,8 @@
   return set_index < k_num_register_sets;
 }
 
-// Used when parsing DWARF and EH frame information and any other
-// object file sections that contain register numbers in them.
+// Used when parsing DWARF and EH frame information and any other object
+// file sections that contain register numbers in them.
 uint32_t RegisterContextPOSIX_arm64::ConvertRegisterKindToRegisterNumber(
     lldb::RegisterKind kind, uint32_t num) {
   const uint32_t num_regs = GetRegisterCount();
Index: source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.cpp
+++ source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.cpp
@@ -91,9 +91,9 @@
 }
 
 const RegisterInfo *RegisterContextPOSIX_mips64::GetRegisterInfo() {
-  // Commonly, this method is overridden and g_register_infos is copied and
-  // specialized.
-  // So, use GetRegisterInfo() rather than g_register_infos in this scope.
+  // Commonly, this method is overridden and g_register_infos is copied
+  // and specialized. So, use GetRegisterInfo() rather than
+  // g_register_infos in this scope.
   return m_register_info_ap->GetRegisterInfo();
 }
 
@@ -156,8 +156,8 @@
 }
 
 lldb::ByteOrder RegisterContextPOSIX_mips64::GetByteOrder() {
-  // Get the target process whose privileged thread was used for the register
-  // read.
+  // Get the target process whose privileged thread was used for the
+  // register read.
   lldb::ByteOrder byte_order = eByteOrderInvalid;
   Process *process = CalculateProcess().get();
 
@@ -172,8 +172,8 @@
   return (set_index < num_sets);
 }
 
-// Used when parsing DWARF and EH frame information and any other
-// object file sections that contain register numbers in them.
+// Used when parsing DWARF and EH frame information and any other object
+// file sections that contain register numbers in them.
 uint32_t RegisterContextPOSIX_mips64::ConvertRegisterKindToRegisterNumber(
     lldb::RegisterKind kind, uint32_t num) {
   const uint32_t num_regs = m_num_registers;
Index: source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.cpp
+++ source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.cpp
@@ -128,9 +128,9 @@
 }
 
 const RegisterInfo *RegisterContextPOSIX_powerpc::GetRegisterInfo() {
-  // Commonly, this method is overridden and g_register_infos is copied and
-  // specialized.
-  // So, use GetRegisterInfo() rather than g_register_infos in this scope.
+  // Commonly, this method is overridden and g_register_infos is copied
+  // and specialized. So, use GetRegisterInfo() rather than
+  // g_register_infos in this scope.
   return m_register_info_ap->GetRegisterInfo();
 }
 
@@ -165,8 +165,8 @@
 }
 
 lldb::ByteOrder RegisterContextPOSIX_powerpc::GetByteOrder() {
-  // Get the target process whose privileged thread was used for the register
-  // read.
+  // Get the target process whose privileged thread was used for the
+  // register read.
   lldb::ByteOrder byte_order = eByteOrderInvalid;
   Process *process = CalculateProcess().get();
 
@@ -181,8 +181,8 @@
   return (set_index < num_sets);
 }
 
-// Used when parsing DWARF and EH frame information and any other
-// object file sections that contain register numbers in them.
+// Used when parsing DWARF and EH frame information and any other object
+// file sections that contain register numbers in them.
 uint32_t RegisterContextPOSIX_powerpc::ConvertRegisterKindToRegisterNumber(
     lldb::RegisterKind kind, uint32_t num) {
   const uint32_t num_regs = GetRegisterCount();
Index: source/Plugins/Process/Utility/RegisterContextPOSIX_ppc64le.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextPOSIX_ppc64le.cpp
+++ source/Plugins/Process/Utility/RegisterContextPOSIX_ppc64le.cpp
@@ -145,9 +145,9 @@
 }
 
 const RegisterInfo *RegisterContextPOSIX_ppc64le::GetRegisterInfo() {
-  // Commonly, this method is overridden and g_register_infos is copied and
-  // specialized.
-  // So, use GetRegisterInfo() rather than g_register_infos in this scope.
+  // Commonly, this method is overridden and g_register_infos is copied
+  // and specialized. So, use GetRegisterInfo() rather than
+  // g_register_infos in this scope.
   return m_register_info_ap->GetRegisterInfo();
 }
 
@@ -182,8 +182,8 @@
 }
 
 lldb::ByteOrder RegisterContextPOSIX_ppc64le::GetByteOrder() {
-  // Get the target process whose privileged thread was used for the register
-  // read.
+  // Get the target process whose privileged thread was used for the
+  // register read.
   lldb::ByteOrder byte_order = eByteOrderInvalid;
   Process *process = CalculateProcess().get();
 
@@ -198,8 +198,8 @@
   return (set_index < num_sets);
 }
 
-// Used when parsing DWARF and EH frame information and any other
-// object file sections that contain register numbers in them.
+// Used when parsing DWARF and EH frame information and any other object
+// file sections that contain register numbers in them.
 uint32_t RegisterContextPOSIX_ppc64le::ConvertRegisterKindToRegisterNumber(
     lldb::RegisterKind kind, uint32_t num) {
   const uint32_t num_regs = GetRegisterCount();
Index: source/Plugins/Process/Utility/RegisterContextPOSIX_s390x.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextPOSIX_s390x.cpp
+++ source/Plugins/Process/Utility/RegisterContextPOSIX_s390x.cpp
@@ -164,8 +164,8 @@
 }
 
 lldb::ByteOrder RegisterContextPOSIX_s390x::GetByteOrder() {
-  // Get the target process whose privileged thread was used for the register
-  // read.
+  // Get the target process whose privileged thread was used for the
+  // register read.
   lldb::ByteOrder byte_order = eByteOrderInvalid;
   Process *process = CalculateProcess().get();
 
@@ -174,8 +174,8 @@
   return byte_order;
 }
 
-// Used when parsing DWARF and EH frame information and any other
-// object file sections that contain register numbers in them.
+// Used when parsing DWARF and EH frame information and any other object
+// file sections that contain register numbers in them.
 uint32_t RegisterContextPOSIX_s390x::ConvertRegisterKindToRegisterNumber(
     lldb::RegisterKind kind, uint32_t num) {
   const uint32_t num_regs = GetRegisterCount();
Index: source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp
+++ source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp
@@ -374,7 +374,8 @@
 
 RegisterContextPOSIX_x86::FPRType RegisterContextPOSIX_x86::GetFPRType() {
   if (m_fpr_type == eNotValid) {
-    // TODO: Use assembly to call cpuid on the inferior and query ebx or ecx
+    // TODO: Use assembly to call cpuid on the inferior and query ebx or
+    // ecx
     m_fpr_type = eXSAVE; // extended floating-point registers, if available
     if (false == ReadFPR())
       m_fpr_type = eFXSAVE; // assume generic floating-point registers
@@ -413,9 +414,9 @@
 }
 
 const RegisterInfo *RegisterContextPOSIX_x86::GetRegisterInfo() {
-  // Commonly, this method is overridden and g_register_infos is copied and
-  // specialized.
-  // So, use GetRegisterInfo() rather than g_register_infos in this scope.
+  // Commonly, this method is overridden and g_register_infos is copied
+  // and specialized. So, use GetRegisterInfo() rather than
+  // g_register_infos in this scope.
   return m_register_info_ap->GetRegisterInfo();
 }
 
@@ -458,8 +459,8 @@
 }
 
 lldb::ByteOrder RegisterContextPOSIX_x86::GetByteOrder() {
-  // Get the target process whose privileged thread was used for the register
-  // read.
+  // Get the target process whose privileged thread was used for the
+  // register read.
   lldb::ByteOrder byte_order = eByteOrderInvalid;
   Process *process = CalculateProcess().get();
 
@@ -523,7 +524,8 @@
 }
 
 bool RegisterContextPOSIX_x86::IsRegisterSetAvailable(size_t set_index) {
-  // Note: Extended register sets are assumed to be at the end of g_reg_sets...
+  // Note: Extended register sets are assumed to be at the end of
+  // g_reg_sets...
   size_t num_sets = k_num_register_sets - k_num_extended_register_sets;
 
   if (GetFPRType() == eXSAVE) // ...and to start with AVX registers.
@@ -531,8 +533,8 @@
   return (set_index < num_sets);
 }
 
-// Used when parsing DWARF and EH frame information and any other
-// object file sections that contain register numbers in them.
+// Used when parsing DWARF and EH frame information and any other object
+// file sections that contain register numbers in them.
 uint32_t RegisterContextPOSIX_x86::ConvertRegisterKindToRegisterNumber(
     lldb::RegisterKind kind, uint32_t num) {
   const uint32_t num_regs = GetRegisterCount();
Index: source/Plugins/Process/Utility/RegisterInfoPOSIX_arm.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterInfoPOSIX_arm.cpp
+++ source/Plugins/Process/Utility/RegisterInfoPOSIX_arm.cpp
@@ -45,7 +45,8 @@
    sizeof(RegisterInfoPOSIX_arm::EXC))
 
 //-----------------------------------------------------------------------------
-// Include RegisterInfos_arm to declare our g_register_infos_arm structure.
+// Include RegisterInfos_arm to declare our g_register_infos_arm
+// structure.
 //-----------------------------------------------------------------------------
 #define DECLARE_REGISTER_INFOS_ARM_STRUCT
 #include "RegisterInfos_arm.h"
Index: source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.cpp
+++ source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.cpp
@@ -50,7 +50,8 @@
    sizeof(RegisterInfoPOSIX_arm64::EXC))
 
 //-----------------------------------------------------------------------------
-// Include RegisterInfos_arm64 to declare our g_register_infos_arm64 structure.
+// Include RegisterInfos_arm64 to declare our g_register_infos_arm64
+// structure.
 //-----------------------------------------------------------------------------
 #define DECLARE_REGISTER_INFOS_ARM64_STRUCT
 #include "RegisterInfos_arm64.h"
Index: source/Plugins/Process/Utility/RegisterInfoPOSIX_ppc64le.cpp
===================================================================
--- source/Plugins/Process/Utility/RegisterInfoPOSIX_ppc64le.cpp
+++ source/Plugins/Process/Utility/RegisterInfoPOSIX_ppc64le.cpp
@@ -17,7 +17,8 @@
 #include "RegisterInfoPOSIX_ppc64le.h"
 
 //-----------------------------------------------------------------------------
-// Include RegisterInfoPOSIX_ppc64le to declare our g_register_infos_ppc64le
+// Include RegisterInfoPOSIX_ppc64le to declare our
+// g_register_infos_ppc64le
 //-----------------------------------------------------------------------------
 #define DECLARE_REGISTER_INFOS_PPC64LE_STRUCT
 #include "RegisterInfos_ppc64le.h"
Index: source/Plugins/Process/Utility/StopInfoMachException.cpp
===================================================================
--- source/Plugins/Process/Utility/StopInfoMachException.cpp
+++ source/Plugins/Process/Utility/StopInfoMachException.cpp
@@ -402,10 +402,9 @@
         {
           if (!exc_sub_code) {
             // This looks like a plain trap.
-            // Have to check if there is a breakpoint here as well.  When you
-            // single-step onto a trap,
-            // the single step stops you not to trap.  Since we also do that
-            // check below, let's just use
+            // Have to check if there is a breakpoint here as well.  When
+            // you single-step onto a trap, the single step stops you not
+            // to trap.  Since we also do that check below, let's just use
             // that logic.
             is_actual_breakpoint = true;
             is_trace_if_actual_breakpoint_missing = true;
@@ -419,8 +418,8 @@
                   (lldb::addr_t)exc_sub_code);
             if (wp_sp && wp_sp->IsEnabled()) {
               // Debugserver may piggyback the hardware index of the fired
-              // watchpoint in the exception data.
-              // Set the hardware index if that's the case.
+              // watchpoint in the exception data. Set the hardware index
+              // if that's the case.
               if (exc_data_count >= 3)
                 wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
               return StopInfo::CreateStopReasonWithWatchpointID(thread,
@@ -450,16 +449,15 @@
         if (exc_code == 0x102) // EXC_ARM_DA_DEBUG
         {
           // It's a watchpoint, then, if the exc_sub_code indicates a
-          // known/enabled
-          // data break address from our watchpoint list.
+          // known/enabled data break address from our watchpoint list.
           lldb::WatchpointSP wp_sp;
           if (target)
             wp_sp = target->GetWatchpointList().FindByAddress(
                 (lldb::addr_t)exc_sub_code);
           if (wp_sp && wp_sp->IsEnabled()) {
             // Debugserver may piggyback the hardware index of the fired
-            // watchpoint in the exception data.
-            // Set the hardware index if that's the case.
+            // watchpoint in the exception data. Set the hardware index if
+            // that's the case.
             if (exc_data_count >= 3)
               wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
             return StopInfo::CreateStopReasonWithWatchpointID(thread,
@@ -473,9 +471,9 @@
           is_actual_breakpoint = true;
           is_trace_if_actual_breakpoint_missing = true;
         } else if (exc_code == 0) // FIXME not EXC_ARM_BREAKPOINT but a kernel
-                                  // is currently returning this so accept it as
-                                  // indicating a breakpoint until the kernel is
-                                  // fixed
+                                  // is currently returning this so accept
+                                  // it as indicating a breakpoint until
+                                  // the kernel is fixed
         {
           is_actual_breakpoint = true;
           is_trace_if_actual_breakpoint_missing = true;
@@ -485,37 +483,35 @@
       case llvm::Triple::aarch64: {
         if (exc_code == 1 && exc_sub_code == 0) // EXC_ARM_BREAKPOINT
         {
-          // This is hit when we single instruction step aka MDSCR_EL1 SS bit 0
-          // is set
+          // This is hit when we single instruction step aka MDSCR_EL1 SS
+          // bit 0 is set
           is_actual_breakpoint = false;
           is_trace_if_actual_breakpoint_missing = true;
         }
         if (exc_code == 0x102) // EXC_ARM_DA_DEBUG
         {
           // It's a watchpoint, then, if the exc_sub_code indicates a
-          // known/enabled
-          // data break address from our watchpoint list.
+          // known/enabled data break address from our watchpoint list.
           lldb::WatchpointSP wp_sp;
           if (target)
             wp_sp = target->GetWatchpointList().FindByAddress(
                 (lldb::addr_t)exc_sub_code);
           if (wp_sp && wp_sp->IsEnabled()) {
             // Debugserver may piggyback the hardware index of the fired
-            // watchpoint in the exception data.
-            // Set the hardware index if that's the case.
+            // watchpoint in the exception data. Set the hardware index if
+            // that's the case.
             if (exc_data_count >= 3)
               wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
             return StopInfo::CreateStopReasonWithWatchpointID(thread,
                                                               wp_sp->GetID());
           }
-          // EXC_ARM_DA_DEBUG seems to be reused for EXC_BREAKPOINT as well as
-          // EXC_BAD_ACCESS
+          // EXC_ARM_DA_DEBUG seems to be reused for EXC_BREAKPOINT as
+          // well as EXC_BAD_ACCESS
           if (thread.GetTemporaryResumeState() == eStateStepping)
             return StopInfo::CreateStopReasonToTrace(thread);
         }
-        // It looks like exc_sub_code has the 4 bytes of the instruction that
-        // triggered the
-        // exception, i.e. our breakpoint opcode
+        // It looks like exc_sub_code has the 4 bytes of the instruction
+        // that triggered the exception, i.e. our breakpoint opcode
         is_actual_breakpoint = exc_code == 1;
         break;
       }
@@ -534,23 +530,22 @@
         if (process_sp)
           bp_site_sp = process_sp->GetBreakpointSiteList().FindByAddress(pc);
         if (bp_site_sp && bp_site_sp->IsEnabled()) {
-          // Update the PC if we were asked to do so, but only do
-          // so if we find a breakpoint that we know about cause
-          // this could be a trap instruction in the code
+          // Update the PC if we were asked to do so, but only do so if we
+          // find a breakpoint that we know about cause this could be a
+          // trap instruction in the code
           if (pc_decrement > 0 && adjust_pc_if_needed)
             reg_ctx_sp->SetPC(pc);
 
-          // If the breakpoint is for this thread, then we'll report the hit,
-          // but if it is for another thread,
-          // we can just report no reason.  We don't need to worry about
-          // stepping over the breakpoint here, that
-          // will be taken care of when the thread resumes and notices that
-          // there's a breakpoint under the pc.
-          // If we have an operating system plug-in, we might have set a thread
-          // specific breakpoint using the
-          // operating system thread ID, so we can't make any assumptions about
-          // the thread ID so we must always
-          // report the breakpoint regardless of the thread.
+          // If the breakpoint is for this thread, then we'll report the
+          // hit, but if it is for another thread, we can just report no
+          // reason.  We don't need to worry about stepping over the
+          // breakpoint here, that will be taken care of when the thread
+          // resumes and notices that there's a breakpoint under the pc.
+          // If we have an operating system plug-in, we might have set a
+          // thread specific breakpoint using the operating system thread
+          // ID, so we can't make any assumptions about the thread ID so
+          // we must always report the breakpoint regardless of the
+          // thread.
           if (bp_site_sp->ValidForThisThread(&thread) ||
               thread.GetProcess()->GetOperatingSystem() != NULL)
             return StopInfo::CreateStopReasonWithBreakpointSiteID(
@@ -561,7 +556,8 @@
             return StopInfoSP();
         }
 
-        // Don't call this a trace if we weren't single stepping this thread.
+        // Don't call this a trace if we weren't single stepping this
+        // thread.
         if (is_trace_if_actual_breakpoint_missing &&
             thread.GetTemporaryResumeState() == eStateStepping) {
           return StopInfo::CreateStopReasonToTrace(thread);
Index: source/Plugins/Process/Utility/UnwindLLDB.cpp
===================================================================
--- source/Plugins/Process/Utility/UnwindLLDB.cpp
+++ source/Plugins/Process/Utility/UnwindLLDB.cpp
@@ -130,18 +130,15 @@
   RegisterContextLLDBSP reg_ctx_sp(new RegisterContextLLDB(
       m_thread, prev_frame->reg_ctx_lldb_sp, cursor_sp->sctx, cur_idx, *this));
 
-  // We want to detect an unwind that cycles erroneously and stop backtracing.
-  // Don't want this maximum unwind limit to be too low -- if you have a
-  // backtrace
-  // with an "infinitely recursing" bug, it will crash when the stack blows out
-  // and the first 35,000 frames are uninteresting - it's the top most 5 frames
-  // that
-  // you actually care about.  So you can't just cap the unwind at 10,000 or
-  // something.
-  // Realistically anything over around 200,000 is going to blow out the stack
-  // space.
-  // If we're still unwinding at that point, we're probably never going to
-  // finish.
+  // We want to detect an unwind that cycles erroneously and stop
+  // backtracing. Don't want this maximum unwind limit to be too low -- if
+  // you have a backtrace with an "infinitely recursing" bug, it will
+  // crash when the stack blows out and the first 35,000 frames are
+  // uninteresting - it's the top most 5 frames that you actually care
+  // about.  So you can't just cap the unwind at 10,000 or something.
+  // Realistically anything over around 200,000 is going to blow out the
+  // stack space. If we're still unwinding at that point, we're probably
+  // never going to finish.
   if (cur_idx > 300000) {
     if (log)
       log->Printf("%*sFrame %d unwound too many frames, assuming unwind has "
@@ -151,14 +148,13 @@
   }
 
   if (reg_ctx_sp.get() == NULL) {
-    // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
-    // that and return
-    // true.  Subsequent calls to TryFallbackUnwindPlan() will return false.
+    // If the RegisterContextLLDB has a fallback UnwindPlan, it will
+    // switch to that and return true.  Subsequent calls to
+    // TryFallbackUnwindPlan() will return false.
     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
       // TryFallbackUnwindPlan for prev_frame succeeded and updated
-      // reg_ctx_lldb_sp field of
-      // prev_frame. However, cfa field of prev_frame still needs to be updated.
-      // Hence updating it.
+      // reg_ctx_lldb_sp field of prev_frame. However, cfa field of
+      // prev_frame still needs to be updated. Hence updating it.
       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
         return nullptr;
 
@@ -172,15 +168,13 @@
   }
 
   if (!reg_ctx_sp->IsValid()) {
-    // We failed to get a valid RegisterContext.
-    // See if the regctx below this on the stack has a fallback unwind plan it
-    // can use.
-    // Subsequent calls to TryFallbackUnwindPlan() will return false.
+    // We failed to get a valid RegisterContext. See if the regctx below
+    // this on the stack has a fallback unwind plan it can use. Subsequent
+    // calls to TryFallbackUnwindPlan() will return false.
     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
       // TryFallbackUnwindPlan for prev_frame succeeded and updated
-      // reg_ctx_lldb_sp field of
-      // prev_frame. However, cfa field of prev_frame still needs to be updated.
-      // Hence updating it.
+      // reg_ctx_lldb_sp field of prev_frame. However, cfa field of
+      // prev_frame still needs to be updated. Hence updating it.
       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
         return nullptr;
 
@@ -194,14 +188,13 @@
     return nullptr;
   }
   if (!reg_ctx_sp->GetCFA(cursor_sp->cfa)) {
-    // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
-    // that and return
-    // true.  Subsequent calls to TryFallbackUnwindPlan() will return false.
+    // If the RegisterContextLLDB has a fallback UnwindPlan, it will
+    // switch to that and return true.  Subsequent calls to
+    // TryFallbackUnwindPlan() will return false.
     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
       // TryFallbackUnwindPlan for prev_frame succeeded and updated
-      // reg_ctx_lldb_sp field of
-      // prev_frame. However, cfa field of prev_frame still needs to be updated.
-      // Hence updating it.
+      // reg_ctx_lldb_sp field of prev_frame. However, cfa field of
+      // prev_frame still needs to be updated. Hence updating it.
       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
         return nullptr;
 
@@ -215,28 +208,22 @@
     return nullptr;
   }
   if (abi && !abi->CallFrameAddressIsValid(cursor_sp->cfa)) {
-    // On Mac OS X, the _sigtramp asynchronous signal trampoline frame may not
-    // have
-    // its (constructed) CFA aligned correctly -- don't do the abi alignment
-    // check for
-    // these.
+    // On Mac OS X, the _sigtramp asynchronous signal trampoline frame may
+    // not have its (constructed) CFA aligned correctly -- don't do the
+    // abi alignment check for these.
     if (reg_ctx_sp->IsTrapHandlerFrame() == false) {
-      // See if we can find a fallback unwind plan for THIS frame.  It may be
-      // that the UnwindPlan we're using for THIS frame was bad and gave us a
-      // bad CFA.
-      // If that's not it, then see if we can change the UnwindPlan for the
-      // frame
-      // below us ("NEXT") -- see if using that other UnwindPlan gets us a
-      // better
-      // unwind state.
+      // See if we can find a fallback unwind plan for THIS frame.  It may
+      // be that the UnwindPlan we're using for THIS frame was bad and
+      // gave us a bad CFA. If that's not it, then see if we can change
+      // the UnwindPlan for the frame below us ("NEXT") -- see if using
+      // that other UnwindPlan gets us a better unwind state.
       if (reg_ctx_sp->TryFallbackUnwindPlan() == false ||
           reg_ctx_sp->GetCFA(cursor_sp->cfa) == false ||
           abi->CallFrameAddressIsValid(cursor_sp->cfa) == false) {
         if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
           // TryFallbackUnwindPlan for prev_frame succeeded and updated
-          // reg_ctx_lldb_sp field of
-          // prev_frame. However, cfa field of prev_frame still needs to be
-          // updated. Hence updating it.
+          // reg_ctx_lldb_sp field of prev_frame. However, cfa field of
+          // prev_frame still needs to be updated. Hence updating it.
           if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
             return nullptr;
 
@@ -258,14 +245,13 @@
     }
   }
   if (!reg_ctx_sp->ReadPC(cursor_sp->start_pc)) {
-    // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
-    // that and return
-    // true.  Subsequent calls to TryFallbackUnwindPlan() will return false.
+    // If the RegisterContextLLDB has a fallback UnwindPlan, it will
+    // switch to that and return true.  Subsequent calls to
+    // TryFallbackUnwindPlan() will return false.
     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
       // TryFallbackUnwindPlan for prev_frame succeeded and updated
-      // reg_ctx_lldb_sp field of
-      // prev_frame. However, cfa field of prev_frame still needs to be updated.
-      // Hence updating it.
+      // reg_ctx_lldb_sp field of prev_frame. However, cfa field of
+      // prev_frame still needs to be updated. Hence updating it.
       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
         return nullptr;
 
@@ -279,14 +265,13 @@
     return nullptr;
   }
   if (abi && !abi->CodeAddressIsValid(cursor_sp->start_pc)) {
-    // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
-    // that and return
-    // true.  Subsequent calls to TryFallbackUnwindPlan() will return false.
+    // If the RegisterContextLLDB has a fallback UnwindPlan, it will
+    // switch to that and return true.  Subsequent calls to
+    // TryFallbackUnwindPlan() will return false.
     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
       // TryFallbackUnwindPlan for prev_frame succeeded and updated
-      // reg_ctx_lldb_sp field of
-      // prev_frame. However, cfa field of prev_frame still needs to be updated.
-      // Hence updating it.
+      // reg_ctx_lldb_sp field of prev_frame. However, cfa field of
+      // prev_frame still needs to be updated. Hence updating it.
       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
         return nullptr;
 
@@ -298,7 +283,8 @@
                   cur_idx < 100 ? cur_idx : 100, "", cur_idx);
     return nullptr;
   }
-  // Infinite loop where the current cursor is the same as the previous one...
+  // Infinite loop where the current cursor is the same as the previous
+  // one...
   if (prev_frame->start_pc == cursor_sp->start_pc &&
       prev_frame->cfa == cursor_sp->cfa) {
     if (log)
@@ -319,14 +305,14 @@
   bool old_m_unwind_complete = m_unwind_complete;
   CursorSP old_m_candidate_frame = m_candidate_frame;
 
-  // Try to unwind 2 more frames using the Unwinder. It uses Full UnwindPlan
-  // and if Full UnwindPlan fails, then uses FallBack UnwindPlan. Also
-  // update the cfa of Frame 0 (if required).
+  // Try to unwind 2 more frames using the Unwinder. It uses Full
+  // UnwindPlan and if Full UnwindPlan fails, then uses FallBack
+  // UnwindPlan. Also update the cfa of Frame 0 (if required).
   AddOneMoreFrame(abi);
 
-  // Remove all the frames added by above function as the purpose of
-  // using above function was just to check whether Unwinder of Frame 0
-  // works or not.
+  // Remove all the frames added by above function as the purpose of using
+  // above function was just to check whether Unwinder of Frame 0 works or
+  // not.
   for (uint32_t i = 1; i < m_frames.size(); i++)
     m_frames.pop_back();
 
@@ -362,60 +348,55 @@
 
   m_frames.push_back(new_frame);
 
-  // If we can get one more frame further then accept that we get back a correct
-  // frame.
+  // If we can get one more frame further then accept that we get back a
+  // correct frame.
   m_candidate_frame = GetOneMoreFrame(abi);
   if (m_candidate_frame)
     return true;
 
-  // We can't go further from the frame returned by GetOneMore frame. Lets try
-  // to get a
-  // different frame with using the fallback unwind plan.
+  // We can't go further from the frame returned by GetOneMore frame. Lets
+  // try to get a different frame with using the fallback unwind plan.
   if (!m_frames[m_frames.size() - 2]
            ->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
-    // We don't have a valid fallback unwind plan. Accept the frame as it is.
-    // This is a
-    // valid situation when we are at the bottom of the stack.
+    // We don't have a valid fallback unwind plan. Accept the frame as it
+    // is. This is a valid situation when we are at the bottom of the
+    // stack.
     return true;
   }
 
-  // Remove the possibly incorrect frame from the frame list and try to add a
-  // different one with
-  // the newly selected fallback unwind plan.
+  // Remove the possibly incorrect frame from the frame list and try to
+  // add a different one with the newly selected fallback unwind plan.
   m_frames.pop_back();
   CursorSP new_frame_v2 = GetOneMoreFrame(abi);
   if (new_frame_v2 == nullptr) {
-    // We haven't got a new frame from the fallback unwind plan. Accept the
-    // frame from the
-    // original unwind plan. This is a valid situation when we are at the bottom
-    // of the stack.
+    // We haven't got a new frame from the fallback unwind plan. Accept
+    // the frame from the original unwind plan. This is a valid situation
+    // when we are at the bottom of the stack.
     m_frames.push_back(new_frame);
     return true;
   }
 
-  // Push the new frame to the list and try to continue from this frame. If we
-  // can get a new frame
-  // then accept it as the correct one.
+  // Push the new frame to the list and try to continue from this frame.
+  // If we can get a new frame then accept it as the correct one.
   m_frames.push_back(new_frame_v2);
   m_candidate_frame = GetOneMoreFrame(abi);
   if (m_candidate_frame) {
-    // If control reached here then TryFallbackUnwindPlan had succeeded for
-    // Cursor::m_frames[m_frames.size() - 2].
-    // It also succeeded to Unwind next 2 frames i.e. m_frames[m_frames.size() -
-    // 1] and a frame after that.
-    // For Cursor::m_frames[m_frames.size() - 2], reg_ctx_lldb_sp field was
-    // already updated during TryFallbackUnwindPlan
-    // call above. However, cfa field still needs to be updated. Hence updating
-    // it here and then returning.
+    // If control reached here then TryFallbackUnwindPlan had succeeded
+    // for Cursor::m_frames[m_frames.size() - 2]. It also succeeded to
+    // Unwind next 2 frames i.e. m_frames[m_frames.size() - 1] and a frame
+    // after that. For Cursor::m_frames[m_frames.size() - 2],
+    // reg_ctx_lldb_sp field was already updated during
+    // TryFallbackUnwindPlan call above. However, cfa field still needs to
+    // be updated. Hence updating it here and then returning.
     if (!(m_frames[m_frames.size() - 2]->reg_ctx_lldb_sp->GetCFA(
             m_frames[m_frames.size() - 2]->cfa)))
       return false;
     return true;
   }
 
-  // The new frame hasn't helped in unwinding. Fall back to the original one as
-  // the default unwind
-  // plan is usually more reliable then the fallback one.
+  // The new frame hasn't helped in unwinding. Fall back to the original
+  // one as the default unwind plan is usually more reliable then the
+  // fallback one.
   m_frames.pop_back();
   m_frames.push_back(new_frame);
   return true;
@@ -486,10 +467,9 @@
   if (static_cast<size_t>(frame_num) >= m_frames.size())
     return false;
 
-  // Never interrogate more than one level while looking for the saved pc value.
-  // If the value
-  // isn't saved by frame_num, none of the frames lower on the stack will have a
-  // useful value.
+  // Never interrogate more than one level while looking for the saved pc
+  // value. If the value isn't saved by frame_num, none of the frames
+  // lower on the stack will have a useful value.
   if (pc_reg) {
     UnwindLLDB::RegisterSearchResult result;
     result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
@@ -504,9 +484,8 @@
     result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
         lldb_regnum, regloc);
 
-    // We descended down to the live register context aka stack frame 0 and are
-    // reading the value
-    // out of a live register.
+    // We descended down to the live register context aka stack frame 0
+    // and are reading the value out of a live register.
     if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound &&
         regloc.type ==
             UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext) {
@@ -514,13 +493,11 @@
     }
 
     // If we have unwind instructions saying that register N is saved in
-    // register M in the middle of
-    // the stack (and N can equal M here, meaning the register was not used in
-    // this function), then
-    // change the register number we're looking for to M and keep looking for a
-    // concrete  location
-    // down the stack, or an actual value from a live RegisterContext at frame
-    // 0.
+    // register M in the middle of the stack (and N can equal M here,
+    // meaning the register was not used in this function), then change
+    // the register number we're looking for to M and keep looking for a
+    // concrete  location down the stack, or an actual value from a live
+    // RegisterContext at frame 0.
     if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound &&
         regloc.type == UnwindLLDB::RegisterLocation::eRegisterInRegister &&
         frame_num > 0) {
Index: source/Plugins/Process/Windows/Common/DebuggerThread.cpp
===================================================================
--- source/Plugins/Process/Windows/Common/DebuggerThread.cpp
+++ source/Plugins/Process/Windows/Common/DebuggerThread.cpp
@@ -111,9 +111,8 @@
 
 lldb::thread_result_t DebuggerThread::DebuggerThreadLaunchRoutine(
     const ProcessLaunchInfo &launch_info) {
-  // Grab a shared_ptr reference to this so that we know it won't get deleted
-  // until after the
-  // thread routine has exited.
+  // Grab a shared_ptr reference to this so that we know it won't get
+  // deleted until after the thread routine has exited.
   std::shared_ptr<DebuggerThread> this_ref(shared_from_this());
 
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
@@ -123,15 +122,12 @@
   Status error;
   ProcessLauncherWindows launcher;
   HostProcess process(launcher.LaunchProcess(launch_info, error));
-  // If we couldn't create the process, notify waiters immediately.  Otherwise
-  // enter the debug
-  // loop and wait until we get the create process debug notification.  Note
-  // that if the process
-  // was created successfully, we can throw away the process handle we got from
-  // CreateProcess
-  // because Windows will give us another (potentially more useful?) handle when
-  // it sends us the
-  // CREATE_PROCESS_DEBUG_EVENT.
+  // If we couldn't create the process, notify waiters immediately.
+  // Otherwise enter the debug loop and wait until we get the create
+  // process debug notification.  Note that if the process was created
+  // successfully, we can throw away the process handle we got from
+  // CreateProcess because Windows will give us another (potentially more
+  // useful?) handle when it sends us the CREATE_PROCESS_DEBUG_EVENT.
   if (error.Success())
     DebugLoop();
   else
@@ -142,9 +138,8 @@
 
 lldb::thread_result_t DebuggerThread::DebuggerThreadAttachRoutine(
     lldb::pid_t pid, const ProcessAttachInfo &attach_info) {
-  // Grab a shared_ptr reference to this so that we know it won't get deleted
-  // until after the
-  // thread routine has exited.
+  // Grab a shared_ptr reference to this so that we know it won't get
+  // deleted until after the thread routine has exited.
   std::shared_ptr<DebuggerThread> this_ref(shared_from_this());
 
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
@@ -157,11 +152,9 @@
     return 0;
   }
 
-  // The attach was successful, enter the debug loop.  From here on out, this is
-  // no different than
-  // a create process operation, so all the same comments in DebugLaunch should
-  // apply from this
-  // point out.
+  // The attach was successful, enter the debug loop.  From here on out,
+  // this is no different than a create process operation, so all the same
+  // comments in DebugLaunch should apply from this point out.
   DebugLoop();
 
   return 0;
@@ -175,34 +168,32 @@
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
   LLDB_LOG(log, "terminate = {0}, inferior={1}.", terminate, pid);
 
-  // Set m_is_shutting_down to true if it was false.  Return if it was already
-  // true.
+  // Set m_is_shutting_down to true if it was false.  Return if it was
+  // already true.
   bool expected = false;
   if (!m_is_shutting_down.compare_exchange_strong(expected, true))
     return error;
 
   // Make a copy of the process, since the termination sequence will reset
-  // DebuggerThread's internal copy and it needs to remain open for the Wait
-  // operation.
+  // DebuggerThread's internal copy and it needs to remain open for the
+  // Wait operation.
   HostProcess process_copy = m_process;
   lldb::process_t handle = m_process.GetNativeProcess().GetSystemHandle();
 
   if (terminate) {
-    // Initiate the termination before continuing the exception, so that the
-    // next debug
-    // event we get is the exit process event, and not some other event.
+    // Initiate the termination before continuing the exception, so that
+    // the next debug event we get is the exit process event, and not some
+    // other event.
     BOOL terminate_suceeded = TerminateProcess(handle, 0);
     LLDB_LOG(log,
              "calling TerminateProcess({0}, 0) (inferior={1}), success={2}",
              handle, pid, terminate_suceeded);
   }
 
-  // If we're stuck waiting for an exception to continue (e.g. the user is at a
-  // breakpoint
-  // messing around in the debugger), continue it now.  But only AFTER calling
-  // TerminateProcess
-  // to make sure that the very next call to WaitForDebugEvent is an exit
-  // process event.
+  // If we're stuck waiting for an exception to continue (e.g. the user is
+  // at a breakpoint messing around in the debugger), continue it now.
+  // But only AFTER calling TerminateProcess to make sure that the very
+  // next call to WaitForDebugEvent is an exit process event.
   if (m_active_exception.get()) {
     LLDB_LOG(log, "masking active exception");
     ContinueAsyncException(ExceptionResult::MaskException);
@@ -342,10 +333,9 @@
   Log *log =
       ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_EVENT | WINDOWS_LOG_EXCEPTION);
   if (m_is_shutting_down) {
-    // A breakpoint that occurs while `m_pid_to_detach` is non-zero is a magic
-    // exception that
-    // we use simply to wake up the DebuggerThread so that we can close out the
-    // debug loop.
+    // A breakpoint that occurs while `m_pid_to_detach` is non-zero is a
+    // magic exception that we use simply to wake up the DebuggerThread so
+    // that we can close out the debug loop.
     if (m_pid_to_detach != 0 &&
         info.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT) {
       LLDB_LOG(log, "Breakpoint exception is cue to detach from process {0:x}",
@@ -354,9 +344,9 @@
       m_detached = true;
     }
 
-    // Don't perform any blocking operations while we're shutting down.  That
-    // will
-    // cause TerminateProcess -> WaitForSingleObject to time out.
+    // Don't perform any blocking operations while we're shutting down.
+    // That will cause TerminateProcess -> WaitForSingleObject to time
+    // out.
     return ExceptionResult::SendToApplication;
   }
 
@@ -408,8 +398,8 @@
   name_stream.flush();
   llvm::set_thread_name(thread_name);
 
-  // info.hProcess and info.hThread are closed automatically by Windows when
-  // EXIT_PROCESS_DEBUG_EVENT is received.
+  // info.hProcess and info.hThread are closed automatically by Windows
+  // when EXIT_PROCESS_DEBUG_EVENT is received.
   m_process = HostProcess(info.hProcess);
   ((HostProcessWindows &)m_process.GetNativeProcess()).SetOwnsHandle(false);
   m_main_thread = HostThread(info.hThread);
Index: source/Plugins/Process/Windows/Common/ProcessWindows.cpp
===================================================================
--- source/Plugins/Process/Windows/Common/ProcessWindows.cpp
+++ source/Plugins/Process/Windows/Common/ProcessWindows.cpp
@@ -76,9 +76,9 @@
 
 namespace lldb_private {
 
-// We store a pointer to this class in the ProcessWindows, so that we don't
-// expose Windows-specific types and implementation details from a public header
-// file.
+// We store a pointer to this class in the ProcessWindows, so that we
+// don't expose Windows-specific types and implementation details from a
+// public header file.
 class ProcessWindowsData {
 public:
   ProcessWindowsData(bool stop_at_entry) : m_stop_at_entry(stop_at_entry) {
@@ -187,8 +187,8 @@
   {
     // Acquire the lock only long enough to get the DebuggerThread.
     // StopDebugging() will trigger a call back into ProcessWindows which
-    // will also acquire the lock.  Thus we have to release the lock before
-    // calling StopDebugging().
+    // will also acquire the lock.  Thus we have to release the lock
+    // before calling StopDebugging().
     llvm::sys::ScopedLock lock(m_mutex);
 
     private_state = GetPrivateState();
@@ -212,8 +212,9 @@
       SetPrivateState(eStateDetached);
     }
 
-    // By the time StopDebugging returns, there is no more debugger thread, so
-    // we can be assured that no other thread will race for the session data.
+    // By the time StopDebugging returns, there is no more debugger
+    // thread, so we can be assured that no other thread will race for the
+    // session data.
     m_session_data.reset();
   } else {
     LLDB_LOG(
@@ -228,11 +229,9 @@
 
 Status ProcessWindows::DoLaunch(Module *exe_module,
                                 ProcessLaunchInfo &launch_info) {
-  // Even though m_session_data is accessed here, it is before a debugger thread
-  // has been
-  // kicked off.  So there's no race conditions, and it shouldn't be necessary
-  // to acquire
-  // the mutex.
+  // Even though m_session_data is accessed here, it is before a debugger
+  // thread has been kicked off.  So there's no race conditions, and it
+  // shouldn't be necessary to acquire the mutex.
 
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
   Status result;
@@ -275,13 +274,11 @@
   LLDB_LOG(log, "successfully launched '{0}'",
            launch_info.GetExecutableFile().GetPath());
 
-  // We've hit the initial stop.  If eLaunchFlagsStopAtEntry was specified, the
-  // private state
-  // should already be set to eStateStopped as a result of hitting the initial
-  // breakpoint.  If
-  // it was not set, the breakpoint should have already been resumed from and
-  // the private state
-  // should already be eStateRunning.
+  // We've hit the initial stop.  If eLaunchFlagsStopAtEntry was
+  // specified, the private state should already be set to eStateStopped
+  // as a result of hitting the initial breakpoint.  If it was not set,
+  // the breakpoint should have already been resumed from and the private
+  // state should already be eStateRunning.
   launch_info.SetProcessID(process.GetProcessId());
   SetID(process.GetProcessId());
 
@@ -321,13 +318,11 @@
 
   LLDB_LOG(log, "successfully attached to process with pid={0}", process_id);
 
-  // We've hit the initial stop.  If eLaunchFlagsStopAtEntry was specified, the
-  // private state
-  // should already be set to eStateStopped as a result of hitting the initial
-  // breakpoint.  If
-  // it was not set, the breakpoint should have already been resumed from and
-  // the private state
-  // should already be eStateRunning.
+  // We've hit the initial stop.  If eLaunchFlagsStopAtEntry was
+  // specified, the private state should already be set to eStateStopped
+  // as a result of hitting the initial breakpoint.  If it was not set,
+  // the breakpoint should have already been resumed from and the private
+  // state should already be eStateRunning.
   SetID(process.GetProcessId());
   return error;
 }
@@ -375,11 +370,10 @@
   DebuggerThreadSP debugger_thread;
   StateType private_state;
   {
-    // Acquire this lock inside an inner scope, only long enough to get the
-    // DebuggerThread.
-    // StopDebugging() will trigger a call back into ProcessWindows which will
-    // acquire the lock
-    // again, so we need to not deadlock.
+    // Acquire this lock inside an inner scope, only long enough to get
+    // the DebuggerThread. StopDebugging() will trigger a call back into
+    // ProcessWindows which will acquire the lock again, so we need to not
+    // deadlock.
     llvm::sys::ScopedLock lock(m_mutex);
 
     private_state = GetPrivateState();
@@ -400,8 +394,9 @@
              private_state);
     error = debugger_thread->StopDebugging(true);
 
-    // By the time StopDebugging returns, there is no more debugger thread, so
-    // we can be assured that no other thread will race for the session data.
+    // By the time StopDebugging returns, there is no more debugger
+    // thread, so we can be assured that no other thread will race for the
+    // session data.
     m_session_data.reset();
   } else {
     LLDB_LOG(log, "cannot destroy process {0} while state = {1}",
@@ -439,8 +434,8 @@
 void ProcessWindows::DidAttach(ArchSpec &arch_spec) {
   llvm::sys::ScopedLock lock(m_mutex);
 
-  // The initial stop won't broadcast the state change event, so account for
-  // that here.
+  // The initial stop won't broadcast the state change event, so account
+  // for that here.
   if (m_session_data && GetPrivateState() == eStateStopped &&
       m_session_data->m_stop_at_entry)
     RefreshStateAfterStop();
@@ -528,8 +523,8 @@
       LLDB_LOG(log,
                "No breakpoint site matches for this thread. __debugbreak()?  "
                "Creating stop info with the exception.");
-      // FALLTHROUGH:  We'll treat this as a generic exception record in the
-      // default case.
+      // FALLTHROUGH:  We'll treat this as a generic exception record in
+      // the default case.
     }
   }
 
@@ -558,16 +553,16 @@
   ModuleSP exe_module_sp(target_sp->GetExecutableModule());
   if (exe_module_sp.get())
     return exe_module_sp->GetFileSpec().Exists();
-  // However, if there is no executable module, we return true since we might be
-  // preparing to attach.
+  // However, if there is no executable module, we return true since we
+  // might be preparing to attach.
   return true;
 }
 
 bool ProcessWindows::UpdateThreadList(ThreadList &old_thread_list,
                                       ThreadList &new_thread_list) {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_THREAD);
-  // Add all the threads that were previously running and for which we did not
-  // detect a thread exited event.
+  // Add all the threads that were previously running and for which we did
+  // not detect a thread exited event.
   int new_size = 0;
   int continued_threads = 0;
   int exited_threads = 0;
@@ -589,8 +584,8 @@
     }
   }
 
-  // Also add all the threads that are new since the last time we broke into the
-  // debugger.
+  // Also add all the threads that are new since the last time we broke
+  // into the debugger.
   for (const auto &thread_info : m_session_data->m_new_threads) {
     ThreadSP thread(new TargetThreadWindows(*this, thread_info.second));
     thread->SetID(thread_info.first);
@@ -699,11 +694,9 @@
   SIZE_T result = ::VirtualQueryEx(handle, addr, &mem_info, sizeof(mem_info));
   if (result == 0) {
     if (::GetLastError() == ERROR_INVALID_PARAMETER) {
-      // ERROR_INVALID_PARAMETER is returned if VirtualQueryEx is called with an
-      // address
-      // past the highest accessible address. We should return a range from the
-      // vm_addr
-      // to LLDB_INVALID_ADDRESS
+      // ERROR_INVALID_PARAMETER is returned if VirtualQueryEx is called
+      // with an address past the highest accessible address. We should
+      // return a range from the vm_addr to LLDB_INVALID_ADDRESS
       info.GetRange().SetRangeBase(vm_addr);
       info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
       info.SetReadable(MemoryRegionInfo::eNo);
@@ -735,7 +728,8 @@
     info.SetWritable(MemoryRegionInfo::eNo);
   }
 
-  // AllocationBase is defined for MEM_COMMIT and MEM_RESERVE but not MEM_FREE.
+  // AllocationBase is defined for MEM_COMMIT and MEM_RESERVE but not
+  // MEM_FREE.
   if (mem_info.State != MEM_FREE) {
     info.GetRange().SetRangeBase(
         reinterpret_cast<addr_t>(mem_info.AllocationBase));
@@ -743,11 +737,9 @@
                                 mem_info.RegionSize);
     info.SetMapped(MemoryRegionInfo::eYes);
   } else {
-    // In the unmapped case we need to return the distance to the next block of
-    // memory.
-    // VirtualQueryEx nearly does that except that it gives the distance from
-    // the start
-    // of the page containing vm_addr.
+    // In the unmapped case we need to return the distance to the next
+    // block of memory. VirtualQueryEx nearly does that except that it
+    // gives the distance from the start of the page containing vm_addr.
     SYSTEM_INFO data;
     GetSystemInfo(&data);
     DWORD page_offset = vm_addr % data.dwPageSize;
@@ -824,11 +816,10 @@
   loaded_modules.Append(module);
   GetTarget().ModulesDidLoad(loaded_modules);
 
-  // Add the main executable module to the list of pending module loads.  We
-  // can't call
-  // GetTarget().ModulesDidLoad() here because we still haven't returned from
-  // DoLaunch() / DoAttach() yet
-  // so the target may not have set the process instance to `this` yet.
+  // Add the main executable module to the list of pending module loads.
+  // We can't call GetTarget().ModulesDidLoad() here because we still
+  // haven't returned from DoLaunch() / DoAttach() yet so the target may
+  // not have set the process instance to `this` yet.
   llvm::sys::ScopedLock lock(m_mutex);
   const HostThreadWindows &wmain_thread =
       debugger->GetMainThread().GetNativeThread();
@@ -842,15 +833,12 @@
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_EXCEPTION);
   llvm::sys::ScopedLock lock(m_mutex);
 
-  // FIXME: Without this check, occasionally when running the test suite there
-  // is
-  // an issue where m_session_data can be null.  It's not clear how this could
-  // happen
-  // but it only surfaces while running the test suite.  In order to properly
-  // diagnose
-  // this, we probably need to first figure allow the test suite to print out
-  // full
-  // lldb logs, and then add logging to the process plugin.
+  // FIXME: Without this check, occasionally when running the test suite
+  // there is an issue where m_session_data can be null.  It's not clear
+  // how this could happen but it only surfaces while running the test
+  // suite.  In order to properly diagnose this, we probably need to first
+  // figure allow the test suite to print out full lldb logs, and then add
+  // logging to the process plugin.
   if (!m_session_data) {
     LLDB_LOG(log, "Debugger thread reported exception {0:x} at address {1:x}, "
                   "but there is no session.",
@@ -911,14 +899,14 @@
 void ProcessWindows::OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) {
   llvm::sys::ScopedLock lock(m_mutex);
 
-  // On a forced termination, we may get exit thread events after the session
-  // data has been cleaned up.
+  // On a forced termination, we may get exit thread events after the
+  // session data has been cleaned up.
   if (!m_session_data)
     return;
 
-  // A thread may have started and exited before the debugger stopped allowing a
-  // refresh.
-  // Just remove it from the new threads list in that case.
+  // A thread may have started and exited before the debugger stopped
+  // allowing a refresh. Just remove it from the new threads list in that
+  // case.
   auto iter = m_session_data->m_new_threads.find(thread_id);
   if (iter != m_session_data->m_new_threads.end())
     m_session_data->m_new_threads.erase(iter);
@@ -929,9 +917,8 @@
 void ProcessWindows::OnLoadDll(const ModuleSpec &module_spec,
                                lldb::addr_t module_addr) {
   // Confusingly, there is no Target::AddSharedModule.  Instead, calling
-  // GetSharedModule() with
-  // a new module will add it to the module list and return a corresponding
-  // ModuleSP.
+  // GetSharedModule() with a new module will add it to the module list
+  // and return a corresponding ModuleSP.
   Status error;
   ModuleSP module = GetTarget().GetSharedModule(module_spec, &error);
   bool load_addr_changed = false;
@@ -961,17 +948,16 @@
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
 
   if (m_session_data->m_initial_stop_received) {
-    // This happened while debugging.  Do we shutdown the debugging session, try
-    // to continue, or do something else?
+    // This happened while debugging.  Do we shutdown the debugging
+    // session, try to continue, or do something else?
     LLDB_LOG(log, "Error {0} occurred during debugging.  Unexpected behavior "
                   "may result.  {1}",
              error.GetError(), error);
   } else {
     // If we haven't actually launched the process yet, this was an error
-    // launching the
-    // process.  Set the internal error and signal the initial stop event so
-    // that the DoLaunch
-    // method wakes up and returns a failure.
+    // launching the process.  Set the internal error and signal the
+    // initial stop event so that the DoLaunch method wakes up and returns
+    // a failure.
     m_session_data->m_launch_error = error;
     ::SetEvent(m_session_data->m_initial_stop_event);
     LLDB_LOG(
@@ -989,7 +975,8 @@
                                             WINDOWS_LOG_BREAKPOINTS);
   LLDB_LOG(log, "Waiting for loader breakpoint.");
 
-  // Block this function until we receive the initial stop from the process.
+  // Block this function until we receive the initial stop from the
+  // process.
   if (::WaitForSingleObject(m_session_data->m_initial_stop_event, INFINITE) ==
       WAIT_OBJECT_0) {
     LLDB_LOG(log, "hit loader breakpoint, returning.");
@@ -1002,8 +989,8 @@
 
 // The Windows page protection bits are NOT independent masks that can be
 // bitwise-ORed together.  For example, PAGE_EXECUTE_READ is not
-// (PAGE_EXECUTE | PAGE_READ).  To test for an access type, it's necessary to
-// test for any of the bits that provide that access type.
+// (PAGE_EXECUTE | PAGE_READ).  To test for an access type, it's necessary
+// to test for any of the bits that provide that access type.
 bool ProcessWindows::IsPageReadable(uint32_t protect) {
   return (protect & PAGE_NOACCESS) == 0;
 }
Index: source/Plugins/Process/Windows/Common/TargetThreadWindows.cpp
===================================================================
--- source/Plugins/Process/Windows/Common/TargetThreadWindows.cpp
+++ source/Plugins/Process/Windows/Common/TargetThreadWindows.cpp
@@ -75,8 +75,8 @@
 #if defined(_WIN64)
       m_reg_context_sp.reset(new RegisterContextWindows_x64(*this, idx));
 #else
-// LLDB is 32-bit, but the target process is 64-bit.  We probably can't debug
-// this.
+// LLDB is 32-bit, but the target process is 64-bit.  We probably can't
+// debug this.
 #endif
     default:
       break;
@@ -91,8 +91,8 @@
 }
 
 Unwind *TargetThreadWindows::GetUnwinder() {
-  // FIXME: Implement an unwinder based on the Windows unwinder exposed through
-  // DIA SDK.
+  // FIXME: Implement an unwinder based on the Windows unwinder exposed
+  // through DIA SDK.
   if (m_unwinder_ap.get() == NULL)
     m_unwinder_ap.reset(new UnwindLLDB(*this));
   return m_unwinder_ap.get();
Index: source/Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.cpp
===================================================================
--- source/Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.cpp
+++ source/Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.cpp
@@ -29,14 +29,12 @@
 namespace {
 
 // This enum defines the layout of the global RegisterInfo array.  This is
-// necessary because
-// lldb register sets are defined in terms of indices into the register array.
-// As such, the
-// order of RegisterInfos defined in global registers array must match the order
-// defined here.
-// When defining the register set layouts, these values can appear in an
-// arbitrary order, and that
-// determines the order that register values are displayed in a dump.
+// necessary because lldb register sets are defined in terms of indices
+// into the register array. As such, the order of RegisterInfos defined in
+// global registers array must match the order defined here. When defining
+// the register set layouts, these values can appear in an arbitrary
+// order, and that determines the order that register values are displayed
+// in a dump.
 enum RegisterIndex {
   eRegisterIndexRax,
   eRegisterIndexRbx,
@@ -160,8 +158,8 @@
 
 static size_t k_num_register_infos = llvm::array_lengthof(g_register_infos);
 
-// Array of lldb register numbers used to define the set of all General Purpose
-// Registers
+// Array of lldb register numbers used to define the set of all General
+// Purpose Registers
 uint32_t g_gpr_reg_indices[] = {
     eRegisterIndexRax, eRegisterIndexRbx, eRegisterIndexRcx,
     eRegisterIndexRdx, eRegisterIndexRdi, eRegisterIndexRsi,
@@ -270,11 +268,10 @@
 
 bool RegisterContextWindows_x64::WriteRegister(const RegisterInfo *reg_info,
                                                const RegisterValue &reg_value) {
-  // Since we cannot only write a single register value to the inferior, we need
-  // to make sure
-  // our cached copy of the register values are fresh.  Otherwise when writing
-  // EAX, for example,
-  // we may also overwrite some other register with a stale value.
+  // Since we cannot only write a single register value to the inferior,
+  // we need to make sure our cached copy of the register values are
+  // fresh.  Otherwise when writing EAX, for example, we may also
+  // overwrite some other register with a stale value.
   if (!CacheAllRegisterValues())
     return false;
 
Index: source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp
===================================================================
--- source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp
+++ source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp
@@ -30,14 +30,12 @@
 namespace {
 
 // This enum defines the layout of the global RegisterInfo array.  This is
-// necessary because
-// lldb register sets are defined in terms of indices into the register array.
-// As such, the
-// order of RegisterInfos defined in global registers array must match the order
-// defined here.
-// When defining the register set layouts, these values can appear in an
-// arbitrary order, and that
-// determines the order that register values are displayed in a dump.
+// necessary because lldb register sets are defined in terms of indices
+// into the register array. As such, the order of RegisterInfos defined in
+// global registers array must match the order defined here. When defining
+// the register set layouts, these values can appear in an arbitrary
+// order, and that determines the order that register values are displayed
+// in a dump.
 enum RegisterIndex {
   eRegisterIndexEax,
   eRegisterIndexEbx,
@@ -132,8 +130,8 @@
 };
 static size_t k_num_register_infos = llvm::array_lengthof(g_register_infos);
 
-// Array of lldb register numbers used to define the set of all General Purpose
-// Registers
+// Array of lldb register numbers used to define the set of all General
+// Purpose Registers
 uint32_t g_gpr_reg_indices[] = {eRegisterIndexEax, eRegisterIndexEbx,
                                 eRegisterIndexEcx, eRegisterIndexEdx,
                                 eRegisterIndexEdi, eRegisterIndexEsi,
@@ -212,11 +210,10 @@
 
 bool RegisterContextWindows_x86::WriteRegister(const RegisterInfo *reg_info,
                                                const RegisterValue &reg_value) {
-  // Since we cannot only write a single register value to the inferior, we need
-  // to make sure
-  // our cached copy of the register values are fresh.  Otherwise when writing
-  // EAX, for example,
-  // we may also overwrite some other register with a stale value.
+  // Since we cannot only write a single register value to the inferior,
+  // we need to make sure our cached copy of the register values are
+  // fresh.  Otherwise when writing EAX, for example, we may also
+  // overwrite some other register with a stale value.
   if (!CacheAllRegisterValues())
     return false;
 
Index: source/Plugins/Process/elf-core/ProcessElfCore.cpp
===================================================================
--- source/Plugins/Process/elf-core/ProcessElfCore.cpp
+++ source/Plugins/Process/elf-core/ProcessElfCore.cpp
@@ -56,9 +56,9 @@
                                                const FileSpec *crash_file) {
   lldb::ProcessSP process_sp;
   if (crash_file) {
-    // Read enough data for a ELF32 header or ELF64 header
-    // Note: Here we care about e_type field only, so it is safe
-    // to ignore possible presence of the header extension.
+    // Read enough data for a ELF32 header or ELF64 header Note: Here we
+    // care about e_type field only, so it is safe to ignore possible
+    // presence of the header extension.
     const size_t header_size = sizeof(llvm::ELF::Elf64_Ehdr);
 
     auto data_sp = DataBufferLLVM::CreateSliceFromPath(crash_file->GetPath(),
@@ -137,8 +137,8 @@
     m_core_aranges.Append(range_entry);
   }
 
-  // Keep a separate map of permissions that that isn't coalesced so all ranges
-  // are maintained.
+  // Keep a separate map of permissions that that isn't coalesced so all
+  // ranges are maintained.
   const uint32_t permissions =
       ((header->p_flags & llvm::ELF::PF_R) ? lldb::ePermissionsReadable : 0u) |
       ((header->p_flags & llvm::ELF::PF_W) ? lldb::ePermissionsWritable : 0u) |
@@ -206,8 +206,8 @@
     m_core_range_infos.Sort();
   }
 
-  // Even if the architecture is set in the target, we need to override
-  // it to match the core file which is always single arch.
+  // Even if the architecture is set in the target, we need to override it
+  // to match the core file which is always single arch.
   ArchSpec arch(m_core_module_sp->GetArchitecture());
 
   ArchSpec target_arch = GetTarget().GetArchitecture();
@@ -228,8 +228,8 @@
       prstatus_signal_found = true;
   }
   if (!siginfo_signal_found) {
-    // If we don't have signal from SIGINFO use the signal from each threads
-    // PRSTATUS note.
+    // If we don't have signal from SIGINFO use the signal from each
+    // threads PRSTATUS note.
     if (prstatus_signal_found) {
       for (auto &thread_data : m_thread_data)
         thread_data.signo = thread_data.prstatus_sig;
@@ -240,9 +240,9 @@
     }
   }
 
-  // Core files are useless without the main executable. See if we can locate
-  // the main
-  // executable using data we found in the core file notes.
+  // Core files are useless without the main executable. See if we can
+  // locate the main executable using data we found in the core file
+  // notes.
   lldb::ModuleSP exe_module_sp = GetTarget().GetExecutableModule();
   if (!exe_module_sp) {
     // The first entry in the NT_FILE might be our executable
@@ -368,17 +368,18 @@
   lldb::addr_t bytes_left =
       0; // Number of bytes available in the core file from the given address
 
-  // Don't proceed if core file doesn't contain the actual data for this address range.
+  // Don't proceed if core file doesn't contain the actual data for this
+  // address range.
   if (file_start == file_end)
     return 0;
 
-  // Figure out how many on-disk bytes remain in this segment
-  // starting at the given offset
+  // Figure out how many on-disk bytes remain in this segment starting at
+  // the given offset
   if (file_end > file_start + offset)
     bytes_left = file_end - (file_start + offset);
 
-  // Figure out how many bytes we need to zero-fill if we are
-  // reading more bytes than available in the on-disk segment
+  // Figure out how many bytes we need to zero-fill if we are reading more
+  // bytes than available in the on-disk segment
   if (bytes_to_read > bytes_left) {
     zero_fill_size = bytes_to_read - bytes_left;
     bytes_to_read = bytes_left;
@@ -421,7 +422,8 @@
   return LLDB_INVALID_ADDRESS;
 }
 
-// Parse a FreeBSD NT_PRSTATUS note - see FreeBSD sys/procfs.h for details.
+// Parse a FreeBSD NT_PRSTATUS note - see FreeBSD sys/procfs.h for
+// details.
 static void ParseFreeBSDPrStatus(ThreadData &thread_data,
                                  const DataExtractor &data,
                                  const ArchSpec &arch) {
@@ -551,8 +553,8 @@
 llvm::Error ProcessElfCore::parseNetBSDNotes(llvm::ArrayRef<CoreNote> notes) {
   ThreadData thread_data;
   for (const auto &note : notes) {
-    // NetBSD per-thread information is stored in notes named
-    // "NetBSD-CORE@nnn" so match on the initial part of the string.
+    // NetBSD per-thread information is stored in notes named "NetBSD-
+    // CORE@nnn" so match on the initial part of the string.
     if (!llvm::StringRef(note.info.n_name).startswith("NetBSD-CORE"))
       continue;
 
@@ -749,9 +751,10 @@
   ArchSpec target_arch = GetTarget().GetArchitecture();
   arch.MergeFrom(target_arch);
 
-  // On MIPS there is no way to differentiate betwenn 32bit and 64bit core files
-  // and this information can't be merged in from the target arch so we fail
-  // back to unconditionally returning the target arch in this config.
+  // On MIPS there is no way to differentiate betwenn 32bit and 64bit core
+  // files and this information can't be merged in from the target arch so
+  // we fail back to unconditionally returning the target arch in this
+  // config.
   if (target_arch.IsMIPS()) {
     return target_arch;
   }
Index: source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.cpp
===================================================================
--- source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.cpp
+++ source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.cpp
@@ -55,8 +55,8 @@
   uint64_t v;
   if (IsGPR(reg_info->kinds[lldb::eRegisterKindLLDB])) {
     if (reg_info->byte_size == 4 && !(arch.GetMachine() == llvm::Triple::mips64el))
-      // In case of 32bit core file, the register data are placed at 4 byte
-      // offset. 
+      // In case of 32bit core file, the register data are placed at 4
+      // byte offset.
       offset = offset / 2;
     v = m_gpr.GetMaxU64(&offset, reg_info->byte_size);
     value = v;
Index: source/Plugins/Process/elf-core/ThreadElfCore.cpp
===================================================================
--- source/Plugins/Process/elf-core/ThreadElfCore.cpp
+++ source/Plugins/Process/elf-core/ThreadElfCore.cpp
@@ -292,8 +292,8 @@
     return error;
   }
 
-  // Read field by field to correctly account for endianess
-  // of both the core dump and the platform running lldb.
+  // Read field by field to correctly account for endianess of both the
+  // core dump and the platform running lldb.
   offset_t offset = 0;
   si_signo = data.GetU32(&offset);
   si_code = data.GetU32(&offset);
@@ -432,8 +432,8 @@
     return error;
   }
 
-  // Parsing from a 32 bit ELF core file, and populating/reusing the structure
-  // properly, because the struct is for the 64 bit version
+  // Parsing from a 32 bit ELF core file, and populating/reusing the
+  // structure properly, because the struct is for the 64 bit version
   offset_t offset = 0;
   si_signo = data.GetU32(&offset);
   si_code = data.GetU32(&offset);
Index: source/Plugins/Process/gdb-remote/GDBRemoteClientBase.cpp
===================================================================
--- source/Plugins/Process/gdb-remote/GDBRemoteClientBase.cpp
+++ source/Plugins/Process/gdb-remote/GDBRemoteClientBase.cpp
@@ -109,16 +109,15 @@
       const bool should_stop = ShouldStop(signals, response);
       response.SetFilePos(0);
 
-      // The packet we should resume with. In the future
-      // we should check our thread list and "do the right thing"
-      // for new threads that show up while we stop and run async
-      // packets. Setting the packet to 'c' to continue all threads
-      // is the right thing to do 99.99% of the time because if a
-      // thread was single stepping, and we sent an interrupt, we
-      // will notice above that we didn't stop due to an interrupt
-      // but stopped due to stepping and we would _not_ continue.
-      // This packet may get modified by the async actions (e.g. to send a
-      // signal).
+      // The packet we should resume with. In the future we should check
+      // our thread list and "do the right thing" for new threads that
+      // show up while we stop and run async packets. Setting the packet
+      // to 'c' to continue all threads is the right thing to do 99.99% of
+      // the time because if a thread was single stepping, and we sent an
+      // interrupt, we will notice above that we didn't stop due to an
+      // interrupt but stopped due to stepping and we would _not_
+      // continue. This packet may get modified by the async actions (e.g.
+      // to send a signal).
       m_continue_packet = 'c';
       cont_lock.unlock();
 
@@ -263,30 +262,28 @@
   if (m_async_count == 0)
     return true; // We were not interrupted. The process stopped on its own.
 
-  // Older debugserver stubs (before April 2016) can return two
-  // stop-reply packets in response to a ^C packet.
-  // Additionally, all debugservers still return two stop replies if
-  // the inferior stops due to some other reason before the remote
-  // stub manages to interrupt it. We need to wait for this
-  // additional packet to make sure the packet sequence does not get
-  // skewed.
+  // Older debugserver stubs (before April 2016) can return two stop-reply
+  // packets in response to a ^C packet. Additionally, all debugservers
+  // still return two stop replies if the inferior stops due to some other
+  // reason before the remote stub manages to interrupt it. We need to
+  // wait for this additional packet to make sure the packet sequence does
+  // not get skewed.
   StringExtractorGDBRemote extra_stop_reply_packet;
   ReadPacket(extra_stop_reply_packet, milliseconds(100), false);
 
-  // Interrupting is typically done using SIGSTOP or SIGINT, so if
-  // the process stops with some other signal, we definitely want to
-  // stop.
+  // Interrupting is typically done using SIGSTOP or SIGINT, so if the
+  // process stops with some other signal, we definitely want to stop.
   const uint8_t signo = response.GetHexU8(UINT8_MAX);
   if (signo != signals.GetSignalNumberFromName("SIGSTOP") &&
       signo != signals.GetSignalNumberFromName("SIGINT"))
     return true;
 
-  // We probably only stopped to perform some async processing, so continue
-  // after that is done.
-  // TODO: This is not 100% correct, as the process may have been stopped with
-  // SIGINT or SIGSTOP that was not caused by us (e.g. raise(SIGINT)). This will
-  // normally cause a stop, but if it's done concurrently with a async
-  // interrupt, that stop will get eaten (llvm.org/pr20231).
+  // We probably only stopped to perform some async processing, so
+  // continue after that is done. TODO: This is not 100% correct, as the
+  // process may have been stopped with SIGINT or SIGSTOP that was not
+  // caused by us (e.g. raise(SIGINT)). This will normally cause a stop,
+  // but if it's done concurrently with a async interrupt, that stop will
+  // get eaten (llvm.org/pr20231).
   return false;
 }
 
@@ -368,8 +365,8 @@
   ++m_comm.m_async_count;
   if (m_comm.m_is_running) {
     if (m_comm.m_async_count == 1) {
-      // The sender has sent the continue packet and we are the first async
-      // packet. Let's interrupt it.
+      // The sender has sent the continue packet and we are the first
+      // async packet. Let's interrupt it.
       const char ctrl_c = '\x03';
       ConnectionStatus status = eConnectionStatusSuccess;
       size_t bytes_written = m_comm.Write(&ctrl_c, 1, status, NULL);
Index: source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
===================================================================
--- source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
+++ source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
@@ -151,8 +151,8 @@
   }
 
   // Stop the communications read thread which is used to parse all
-  // incoming packets.  This function will block until the read
-  // thread returns.
+  // incoming packets.  This function will block until the read thread
+  // returns.
   if (m_read_thread_enabled)
     StopReadThread();
 }
@@ -217,12 +217,10 @@
         }
       }
 
-      // If logging was just enabled and we have history, then dump out what
-      // we have to the log so we get the historical context. The Dump() call
-      // that
-      // logs all of the packet will set a boolean so that we don't dump this
-      // more
-      // than once
+      // If logging was just enabled and we have history, then dump out
+      // what we have to the log so we get the historical context. The
+      // Dump() call that logs all of the packet will set a boolean so
+      // that we don't dump this more than once
       if (!m_history.DidDumpToLog())
         m_history.Dump(log);
 
@@ -301,10 +299,10 @@
     return WaitForPacketNoLock(response, timeout, sync_on_timeout);
 }
 
-// This function is called when a packet is requested.
-// A whole packet is popped from the packet queue and returned to the caller.
-// Packets are placed into this queue from the communication read thread.
-// See GDBRemoteCommunication::AppendBytesToCache.
+// This function is called when a packet is requested. A whole packet is
+// popped from the packet queue and returned to the caller. Packets are
+// placed into this queue from the communication read thread. See
+// GDBRemoteCommunication::AppendBytesToCache.
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunication::PopPacketFromQueue(StringExtractorGDBRemote &response,
                                            Timeout<std::micro> timeout) {
@@ -424,10 +422,9 @@
                   break;
                 } else if (successful_responses == 1) {
                   // We got something else back as the first successful
-                  // response, it probably is
-                  // the  response to the packet we actually wanted, so copy it
-                  // over if this
-                  // is the first success and continue to try to get the qEcho
+                  // response, it probably is the  response to the packet
+                  // we actually wanted, so copy it over if this is the
+                  // first success and continue to try to get the qEcho
                   // response
                   packet = echo_response;
                   got_actual_response = true;
@@ -440,15 +437,15 @@
             }
           }
 
-          // We weren't able to sync back up with the server, we must abort
-          // otherwise
-          // all responses might not be from the right packets...
+          // We weren't able to sync back up with the server, we must
+          // abort otherwise all responses might not be from the right
+          // packets...
           if (sync_success) {
             // We timed out, but were able to recover
             if (got_actual_response) {
-              // We initially timed out, but we did get a response that came in
-              // before the successful
-              // reply to our qEcho packet, so lets say everything is fine...
+              // We initially timed out, but we did get a response that
+              // came in before the successful reply to our qEcho packet,
+              // so lets say everything is fine...
               return PacketResult::Success;
             }
           } else {
@@ -490,10 +487,9 @@
 
   size_t pkt_size = m_bytes.size();
 
-  // Smallest possible compressed packet is $N#00 - an uncompressed empty reply,
-  // most commonly indicating
-  // an unsupported packet.  Anything less than 5 characters, it's definitely
-  // not a compressed packet.
+  // Smallest possible compressed packet is $N#00 - an uncompressed empty
+  // reply, most commonly indicating an unsupported packet.  Anything less
+  // than 5 characters, it's definitely not a compressed packet.
   if (pkt_size < 5)
     return true;
 
@@ -516,23 +512,22 @@
       pkt_size -
       5; // not counting '$', 'C' | 'N', '#', & the two hex checksum chars
   size_t content_start = 2; // The first character of the
-                            // compressed/not-compressed text of the packet
+                            // compressed/not-compressed text of the
+                            // packet
   size_t checksum_idx =
       hash_mark_idx +
       1; // The first character of the two hex checksum characters
 
-  // Normally size_of_first_packet == m_bytes.size() but m_bytes may contain
-  // multiple packets.
-  // size_of_first_packet is the size of the initial packet which we'll replace
-  // with the decompressed
-  // version of, leaving the rest of m_bytes unmodified.
+  // Normally size_of_first_packet == m_bytes.size() but m_bytes may
+  // contain multiple packets. size_of_first_packet is the size of the
+  // initial packet which we'll replace with the decompressed version of,
+  // leaving the rest of m_bytes unmodified.
   size_t size_of_first_packet = hash_mark_idx + 3;
 
-  // Compressed packets ("$C") start with a base10 number which is the size of
-  // the uncompressed payload,
-  // then a : and then the compressed data.  e.g. $C1024:<binary>#00
-  // Update content_start and content_length to only include the <binary> part
-  // of the packet.
+  // Compressed packets ("$C") start with a base10 number which is the
+  // size of the uncompressed payload, then a : and then the compressed
+  // data.  e.g. $C1024:<binary>#00 Update content_start and
+  // content_length to only include the <binary> part of the packet.
 
   uint64_t decompressed_bufsize = ULONG_MAX;
   if (m_bytes[1] == 'C') {
@@ -587,9 +582,8 @@
     return true;
   }
 
-  // Reverse the gdb-remote binary escaping that was done to the compressed text
-  // to
-  // guard characters like '$', '#', '}', etc.
+  // Reverse the gdb-remote binary escaping that was done to the
+  // compressed text to guard characters like '$', '#', '}', etc.
   std::vector<uint8_t> unescaped_content;
   unescaped_content.reserve(content_length);
   size_t i = content_start;
@@ -615,8 +609,8 @@
   }
 
 #if defined(HAVE_LIBCOMPRESSION)
-  // libcompression is weak linked so check that compression_decode_buffer() is
-  // available
+  // libcompression is weak linked so check that
+  // compression_decode_buffer() is available
   if (m_compression_type == CompressionType::ZlibDeflate ||
       m_compression_type == CompressionType::LZFSE ||
       m_compression_type == CompressionType::LZ4) {
@@ -630,12 +624,10 @@
     else if (m_compression_type == CompressionType::LZMA)
       compression_type = COMPRESSION_LZMA;
 
-    // If we have the expected size of the decompressed payload, we can allocate
-    // the right-sized buffer and do it.  If we don't have that information,
-    // we'll
-    // need to try decoding into a big buffer and if the buffer wasn't big
-    // enough,
-    // increase it and try again.
+    // If we have the expected size of the decompressed payload, we can
+    // allocate the right-sized buffer and do it.  If we don't have that
+    // information, we'll need to try decoding into a big buffer and if
+    // the buffer wasn't big enough, increase it and try again.
 
     if (decompressed_bufsize != ULONG_MAX && decompressed_buffer != nullptr) {
       decompressed_bytes = compression_decode_buffer(
@@ -723,9 +715,8 @@
 
   // Parse up the packets into gdb remote packets
   if (!m_bytes.empty()) {
-    // end_idx must be one past the last valid packet byte. Start
-    // it off with an invalid value that is the same as the current
-    // index.
+    // end_idx must be one past the last valid packet byte. Start it off
+    // with an invalid value that is the same as the current index.
     size_t content_start = 0;
     size_t content_length = 0;
     size_t total_length = 0;
@@ -760,7 +751,8 @@
             checksum_idx = hash_pos + 1;
             // Skip the dollar sign
             content_start = 1;
-            // Don't include the # in the content or the $ in the content length
+            // Don't include the # in the content or the $ in the content
+            // length
             content_length = hash_pos - 1;
 
             total_length =
@@ -774,11 +766,11 @@
       break;
 
     default: {
-      // We have an unexpected byte and we need to flush all bad
-      // data that is in m_bytes, so we need to find the first
-      // byte that is a '+' (ACK), '-' (NACK), \x03 (CTRL+C interrupt),
-      // or '$' character (start of packet header) or of course,
-      // the end of the data in m_bytes...
+      // We have an unexpected byte and we need to flush all bad data that
+      // is in m_bytes, so we need to find the first byte that is a '+'
+      // (ACK), '-' (NACK), \x03 (CTRL+C interrupt), or '$' character
+      // (start of packet header) or of course, the end of the data in
+      // m_bytes...
       const size_t bytes_len = m_bytes.size();
       bool done = false;
       uint32_t idx;
@@ -817,18 +809,16 @@
       bool success = true;
       std::string &packet_str = packet.GetStringRef();
       if (log) {
-        // If logging was just enabled and we have history, then dump out what
-        // we have to the log so we get the historical context. The Dump() call
-        // that
-        // logs all of the packet will set a boolean so that we don't dump this
-        // more
-        // than once
+        // If logging was just enabled and we have history, then dump out
+        // what we have to the log so we get the historical context. The
+        // Dump() call that logs all of the packet will set a boolean so
+        // that we don't dump this more than once
         if (!m_history.DidDumpToLog())
           m_history.Dump(log);
 
         bool binary = false;
-        // Only detect binary for packets that start with a '$' and have a '#CC'
-        // checksum
+        // Only detect binary for packets that start with a '$' and have a
+        // '#CC' checksum
         if (m_bytes[0] == '$' && total_length > 4) {
           for (size_t i = 0; !binary && i < total_length; ++i) {
             unsigned char c = m_bytes[i];
@@ -880,26 +870,25 @@
 
       // Clear packet_str in case there is some existing data in it.
       packet_str.clear();
-      // Copy the packet from m_bytes to packet_str expanding the
-      // run-length encoding in the process.
-      // Reserve enough byte for the most common case (no RLE used)
+      // Copy the packet from m_bytes to packet_str expanding the run-
+      // length encoding in the process. Reserve enough byte for the most
+      // common case (no RLE used)
       packet_str.reserve(m_bytes.length());
       for (std::string::const_iterator c = m_bytes.begin() + content_start;
            c != m_bytes.begin() + content_end; ++c) {
         if (*c == '*') {
-          // '*' indicates RLE. Next character will give us the
-          // repeat count and previous character is what is to be
-          // repeated.
+          // '*' indicates RLE. Next character will give us the repeat
+          // count and previous character is what is to be repeated.
           char char_to_repeat = packet_str.back();
           // Number of time the previous character is repeated
           int repeat_count = *++c + 3 - ' ';
-          // We have the char_to_repeat and repeat_count. Now push
-          // it in the packet.
+          // We have the char_to_repeat and repeat_count. Now push it in
+          // the packet.
           for (int i = 0; i < repeat_count; ++i)
             packet_str.push_back(char_to_repeat);
         } else if (*c == 0x7d) {
-          // 0x7d is the escape character.  The next character is to
-          // be XOR'd with 0x20.
+          // 0x7d is the escape character.  The next character is to be
+          // XOR'd with 0x20.
           char escapee = *++c ^ 0x20;
           packet_str.push_back(escapee);
         } else {
@@ -1039,8 +1028,8 @@
         debugserver_file_spec =
             platform->LocateExecutable(DEBUGSERVER_BASENAME);
         if (debugserver_file_spec) {
-          // Platform::LocateExecutable() wouldn't return a path if it doesn't
-          // exist
+          // Platform::LocateExecutable() wouldn't return a path if it
+          // doesn't exist
           debugserver_exists = true;
         } else {
           if (log)
@@ -1049,8 +1038,7 @@
                         __FUNCTION__, debugserver_file_spec.GetPath().c_str());
         }
         // Don't cache the platform specific GDB server binary as it could
-        // change
-        // from platform to platform
+        // change from platform to platform
         g_debugserver_file_spec.Clear();
       }
     }
@@ -1092,23 +1080,23 @@
     }
 
     llvm::SmallString<PATH_MAX> named_pipe_path;
-    // socket_pipe is used by debug server to communicate back either
-    // TCP port or domain socket name which it listens on.
-    // The second purpose of the pipe to serve as a synchronization point -
-    // once data is written to the pipe, debug server is up and running.
+    // socket_pipe is used by debug server to communicate back either TCP
+    // port or domain socket name which it listens on. The second purpose
+    // of the pipe to serve as a synchronization point - once data is
+    // written to the pipe, debug server is up and running.
     Pipe socket_pipe;
 
     // port is null when debug server should listen on domain socket -
-    // we're not interested in port value but rather waiting for debug server
-    // to become available.
+    // we're not interested in port value but rather waiting for debug
+    // server to become available.
     if (pass_comm_fd == -1) {
       if (url) {
 // Create a temporary file to get the stdout/stderr and redirect the
-// output of the command into this file. We will later read this file
-// if all goes well and fill the data into "command_output_ptr"
+// output of the command into this file. We will later read this file if
+// all goes well and fill the data into "command_output_ptr"
 #if defined(__APPLE__)
-        // Binding to port zero, we need to figure out what port it ends up
-        // using using a named pipe...
+        // Binding to port zero, we need to figure out what port it ends
+        // up using using a named pipe...
         error = socket_pipe.CreateWithUniqueName("debugserver-named-pipe",
                                                  false, named_pipe_path);
         if (error.Fail()) {
@@ -1121,8 +1109,8 @@
         debugserver_args.AppendArgument(llvm::StringRef("--named-pipe"));
         debugserver_args.AppendArgument(named_pipe_path);
 #else
-        // Binding to port zero, we need to figure out what port it ends up
-        // using using an unnamed pipe...
+        // Binding to port zero, we need to figure out what port it ends
+        // up using using an unnamed pipe...
         error = socket_pipe.CreateNew(true);
         if (error.Fail()) {
           if (log)
@@ -1138,8 +1126,7 @@
 #endif
       } else {
         // No host and port given, so lets listen on our end and make the
-        // debugserver
-        // connect to us..
+        // debugserver connect to us..
         error = StartListenThread("127.0.0.1", 0);
         if (error.Fail()) {
           if (log)
@@ -1156,9 +1143,9 @@
         if (port_ > 0) {
           char port_cstr[32];
           snprintf(port_cstr, sizeof(port_cstr), "127.0.0.1:%i", port_);
-          // Send the host and port down that debugserver and specify an option
-          // so that it connects back to the port we are listening to in this
-          // process
+          // Send the host and port down that debugserver and specify an
+          // option so that it connects back to the port we are listening
+          // to in this process
           debugserver_args.AppendArgument(llvm::StringRef("--reverse-connect"));
           debugserver_args.AppendArgument(llvm::StringRef(port_cstr));
           if (port)
@@ -1198,8 +1185,8 @@
     }
 #endif
 
-    // Add additional args, starting with LLDB_DEBUGSERVER_EXTRA_ARG_1 until an
-    // env var doesn't come back.
+    // Add additional args, starting with LLDB_DEBUGSERVER_EXTRA_ARG_1
+    // until an env var doesn't come back.
     uint32_t env_var_index = 1;
     bool has_env_var;
     do {
@@ -1340,15 +1327,13 @@
     m_gdb_comm.SetPacketTimeout(m_saved_timeout);
 }
 
-// This function is called via the Communications class read thread when bytes
-// become available
-// for this connection. This function will consume all incoming bytes and try to
-// parse whole
-// packets as they become available. Full packets are placed in a queue, so that
-// all packet
-// requests can simply pop from this queue. Async notification packets will be
-// dispatched
-// immediately to the ProcessGDBRemote Async thread via an event.
+// This function is called via the Communications class read thread when
+// bytes become available for this connection. This function will consume
+// all incoming bytes and try to parse whole packets as they become
+// available. Full packets are placed in a queue, so that all packet
+// requests can simply pop from this queue. Async notification packets
+// will be dispatched immediately to the ProcessGDBRemote Async thread via
+// an event.
 void GDBRemoteCommunication::AppendBytesToCache(const uint8_t *bytes,
                                                 size_t len, bool broadcast,
                                                 lldb::ConnectionStatus status) {
@@ -1357,8 +1342,8 @@
   while (true) {
     PacketType type = CheckForPacket(bytes, len, packet);
 
-    // scrub the data so we do not pass it back to CheckForPacket
-    // on future passes of the loop
+    // scrub the data so we do not pass it back to CheckForPacket on
+    // future passes of the loop
     bytes = nullptr;
     len = 0;
 
@@ -1382,8 +1367,8 @@
       // put this packet into an event
       const char *pdata = packet.GetStringRef().c_str();
 
-      // as the communication class, we are a broadcaster and the
-      // async thread is tuned to listen to us
+      // as the communication class, we are a broadcaster and the async
+      // thread is tuned to listen to us
       BroadcastEvent(eBroadcastBitGdbReadThreadGotNotify,
                      new EventDataBytes(pdata));
     }
Index: source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
===================================================================
--- source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
+++ source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
@@ -129,10 +129,10 @@
     while (packet_result == PacketResult::Success)
       packet_result = ReadPacket(response, milliseconds(10), false);
 
-    // The return value from QueryNoAckModeSupported() is true if the packet
-    // was sent and _any_ response (including UNIMPLEMENTED) was received),
-    // or false if no response was received. This quickly tells us if we have
-    // a live connection to a remote GDB server...
+    // The return value from QueryNoAckModeSupported() is true if the
+    // packet was sent and _any_ response (including UNIMPLEMENTED) was
+    // received), or false if no response was received. This quickly tells
+    // us if we have a live connection to a remote GDB server...
     if (QueryNoAckModeSupported()) {
       return true;
     } else {
@@ -214,10 +214,9 @@
     m_send_acks = true;
     m_supports_not_sending_acks = eLazyBoolNo;
 
-    // This is the first real packet that we'll send in a debug session and it
-    // may take a little
-    // longer than normal to receive a reply.  Wait at least 6 seconds for a
-    // reply to this packet.
+    // This is the first real packet that we'll send in a debug session
+    // and it may take a little longer than normal to receive a reply.
+    // Wait at least 6 seconds for a reply to this packet.
 
     ScopedTimeout timeout(*this, std::max(GetPacketTimeout(), seconds(6)));
 
@@ -283,7 +282,8 @@
 
 void GDBRemoteCommunicationClient::ResetDiscoverableSettings(bool did_exec) {
   if (did_exec == false) {
-    // Hard reset everything, this is when we first connect to a GDB server
+    // Hard reset everything, this is when we first connect to a GDB
+    // server
     m_supports_not_sending_acks = eLazyBoolCalculate;
     m_supports_thread_suffix = eLazyBoolCalculate;
     m_supports_threads_in_stop_reply = eLazyBoolCalculate;
@@ -340,14 +340,15 @@
     m_supports_jModulesInfo = true;
   }
 
-  // These flags should be reset when we first connect to a GDB server
-  // and when our inferior process execs
+  // These flags should be reset when we first connect to a GDB server and
+  // when our inferior process execs
   m_qProcessInfo_is_valid = eLazyBoolCalculate;
   m_process_arch.Clear();
 }
 
 void GDBRemoteCommunicationClient::GetRemoteQSupported() {
-  // Clear out any capabilities we expect to see in the qSupported response
+  // Clear out any capabilities we expect to see in the qSupported
+  // response
   m_supports_qXfer_auxv_read = eLazyBoolNo;
   m_supports_qXfer_libraries_read = eLazyBoolNo;
   m_supports_qXfer_libraries_svr4_read = eLazyBoolNo;
@@ -393,7 +394,8 @@
       m_supports_qXfer_memory_map_read = eLazyBoolYes;
 
     // Look for a list of compressions in the features list e.g.
-    // qXfer:features:read+;PacketSize=20000;qEcho+;SupportedCompressions=zlib-deflate,lzma
+    // qXfer:features:read+;PacketSize=20000;qEcho+;SupportedCompressions
+    // =zlib-deflate,lzma
     const char *features_list = ::strstr(response_cstr, "qXfer:features:");
     if (features_list) {
       const char *compressions =
@@ -557,9 +559,9 @@
   return SendPacketAndWaitForResponseNoLock(payload.GetString(), response);
 }
 
-// Check if the target supports 'p' packet. It sends out a 'p'
-// packet and checks the response. A normal packet will tell us
-// that support is available.
+// Check if the target supports 'p' packet. It sends out a 'p' packet and
+// checks the response. A normal packet will tell us that support is
+// available.
 //
 // Takes a valid thread ID because p needs to apply to a thread.
 bool GDBRemoteCommunicationClient::GetpPacketSupported(lldb::tid_t tid) {
@@ -614,8 +616,8 @@
 void GDBRemoteCommunicationClient::EnableErrorStringInPacket() {
   if (m_supports_error_string_reply == eLazyBoolCalculate) {
     StringExtractorGDBRemote response;
-    // We try to enable error strings in remote packets
-    // but if we fail, we just work in the older way.
+    // We try to enable error strings in remote packets but if we fail, we
+    // just work in the older way.
     m_supports_error_string_reply = eLazyBoolNo;
     if (SendPacketAndWaitForResponse("QEnableErrorStrings", response, false) ==
         PacketResult::Success) {
@@ -704,8 +706,8 @@
 
     const std::string &this_string = this_response.GetStringRef();
 
-    // Check for m or l as first character; l seems to mean this is the last
-    // chunk
+    // Check for m or l as first character; l seems to mean this is the
+    // last chunk
     char first_char = *this_string.c_str();
     if (first_char != 'm' && first_char != 'l') {
       return PacketResult::ErrorReplyInvalid;
@@ -728,13 +730,11 @@
     // We really got it.
     return m_curr_pid;
   } else {
-    // If we don't get a response for qProcessInfo, check if $qC gives us a
-    // result.
-    // $qC only returns a real process id on older debugserver and lldb-platform
-    // stubs.
-    // The gdb remote protocol documents $qC as returning the thread id, which
-    // newer
-    // debugserver and lldb-gdbserver stubs return correctly.
+    // If we don't get a response for qProcessInfo, check if $qC gives us
+    // a result. $qC only returns a real process id on older debugserver
+    // and lldb-platform stubs. The gdb remote protocol documents $qC as
+    // returning the thread id, which newer debugserver and lldb-gdbserver
+    // stubs return correctly.
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse("qC", response, false) ==
         PacketResult::Success) {
@@ -788,9 +788,9 @@
 
 int GDBRemoteCommunicationClient::SendArgumentsPacket(
     const ProcessLaunchInfo &launch_info) {
-  // Since we don't get the send argv0 separate from the executable path, we
-  // need to
-  // make sure to use the actual executable path found in the launch_info...
+  // Since we don't get the send argv0 separate from the executable path,
+  // we need to make sure to use the actual executable path found in the
+  // launch_info...
   std::vector<const char *> argv;
   FileSpec exe_file = launch_info.GetExecutableFile();
   std::string exe_path;
@@ -1531,8 +1531,8 @@
       }
 
       if (region_info.GetRange().IsValid()) {
-        // We got a valid address range back but no permissions -- which means
-        // this is an unmapped page
+        // We got a valid address range back but no permissions -- which
+        // means this is an unmapped page
         if (!saw_permissions) {
           region_info.SetReadable(MemoryRegionInfo::eNo);
           region_info.SetWritable(MemoryRegionInfo::eNo);
@@ -1567,9 +1567,9 @@
       region_info.Clear();
     }
   } else if (qXfer_error.Success()) {
-    // If both qMemoryRegionInfo and qXfer:memory-map:read succeeded, and if
-    // both regions are the same range, update the result to include the
-    // flash-memory information that is specific to the qXfer result.
+    // If both qMemoryRegionInfo and qXfer:memory-map:read succeeded, and
+    // if both regions are the same range, update the result to include
+    // the flash-memory information that is specific to the qXfer result.
     if (region_info.GetRange() == qXfer_region_info.GetRange()) {
       region_info.SetFlash(qXfer_region_info.GetFlash());
       region_info.SetBlocksize(qXfer_region_info.GetBlocksize());
@@ -1749,8 +1749,8 @@
     else
       after = true;
   } else {
-    // For MIPS and ppc64le, set m_watchpoints_trigger_after_instruction to
-    // eLazyBoolNo if it is not calculated before.
+    // For MIPS and ppc64le, set m_watchpoints_trigger_after_instruction
+    // to eLazyBoolNo if it is not calculated before.
     if ((m_watchpoints_trigger_after_instruction == eLazyBoolCalculate &&
          (atype == llvm::Triple::mips || atype == llvm::Triple::mipsel ||
           atype == llvm::Triple::mips64 || atype == llvm::Triple::mips64el)) ||
@@ -1939,8 +1939,8 @@
         process_info.GetArchitecture().SetTriple(triple.c_str());
       } else if (name.equals("name")) {
         StringExtractor extractor(value);
-        // The process name from ASCII hex bytes since we can't
-        // control the characters in a process name
+        // The process name from ASCII hex bytes since we can't control
+        // the characters in a process name
         std::string name;
         extractor.GetHexByteString(name);
         process_info.GetExecutableFile().SetFile(name, false);
@@ -2196,8 +2196,8 @@
       }
     }
     StringExtractorGDBRemote response;
-    // Increase timeout as the first qfProcessInfo packet takes a long time
-    // on Android. The value of 1min was arrived at empirically.
+    // Increase timeout as the first qfProcessInfo packet takes a long
+    // time on Android. The value of 1min was arrived at empirically.
     ScopedTimeout timeout(*this, minutes(1));
     if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
         PacketResult::Success) {
@@ -2230,9 +2230,10 @@
     if (SendPacketAndWaitForResponse(packet, response, false) ==
         PacketResult::Success) {
       if (response.IsNormalResponse()) {
-        // Make sure we parsed the right number of characters. The response is
-        // the hex encoded user name and should make up the entire packet.
-        // If there are any non-hex ASCII bytes, the length won't match below..
+        // Make sure we parsed the right number of characters. The
+        // response is the hex encoded user name and should make up the
+        // entire packet. If there are any non-hex ASCII bytes, the length
+        // won't match below..
         if (response.GetHexByteString(name) * 2 ==
             response.GetStringRef().size())
           return true;
@@ -2257,9 +2258,10 @@
     if (SendPacketAndWaitForResponse(packet, response, false) ==
         PacketResult::Success) {
       if (response.IsNormalResponse()) {
-        // Make sure we parsed the right number of characters. The response is
-        // the hex encoded group name and should make up the entire packet.
-        // If there are any non-hex ASCII bytes, the length won't match below..
+        // Make sure we parsed the right number of characters. The
+        // response is the hex encoded group name and should make up the
+        // entire packet. If there are any non-hex ASCII bytes, the length
+        // won't match below..
         if (response.GetHexByteString(name) * 2 ==
             response.GetStringRef().size())
           return true;
@@ -2401,8 +2403,8 @@
     for (uint32_t recv_size = 32; recv_size <= max_recv; recv_size *= 2) {
       MakeSpeedTestPacket(packet, send_size, recv_size);
 
-      // If we have a receive size, test how long it takes to receive 4MB of
-      // data
+      // If we have a receive size, test how long it takes to receive 4MB
+      // of data
       if (recv_size > 0) {
         const auto start_time = steady_clock::now();
         uint32_t bytes_read = 0;
@@ -2482,11 +2484,12 @@
     hostname = remote_accept_hostname;
   else {
     if (HostInfo::GetHostname(hostname)) {
-      // Make the GDB server we launch only accept connections from this host
+      // Make the GDB server we launch only accept connections from this
+      // host
       stream.Printf("host:%s;", hostname.c_str());
     } else {
-      // Make the GDB server we launch accept connections from any host since we
-      // can't figure out the hostname
+      // Make the GDB server we launch accept connections from any host
+      // since we can't figure out the hostname
       stream.Printf("host:*;");
     }
   }
@@ -2685,10 +2688,11 @@
   assert(packet_len + 1 < (int)sizeof(packet));
   UNUSED_IF_ASSERT_DISABLED(packet_len);
   StringExtractorGDBRemote response;
-  // Make sure the response is either "OK", "EXX" where XX are two hex digits,
-  // or "" (unsupported)
+  // Make sure the response is either "OK", "EXX" where XX are two hex
+  // digits, or "" (unsupported)
   response.SetResponseValidatorToOKErrorNotSupported();
-  // Try to send the breakpoint packet, and check that it was correctly sent
+  // Try to send the breakpoint packet, and check that it was correctly
+  // sent
   if (SendPacketAndWaitForResponse(packet, response, true) ==
       PacketResult::Success) {
     // Receive and OK packet when the breakpoint successfully placed
@@ -3061,8 +3065,8 @@
   Status error;
   lldb_private::StreamGDBRemote stream;
   stream.PutCString("vFile:symlink:");
-  // the unix symlink() command reverses its parameters where the dst if first,
-  // so we follow suit here
+  // the unix symlink() command reverses its parameters where the dst if
+  // first, so we follow suit here
   stream.PutCStringAsRawHex8(dst_path.c_str());
   stream.PutChar(',');
   stream.PutCStringAsRawHex8(src_path.c_str());
@@ -3094,8 +3098,8 @@
   Status error;
   lldb_private::StreamGDBRemote stream;
   stream.PutCString("vFile:unlink:");
-  // the unix symlink() command reverses its parameters where the dst if first,
-  // so we follow suit here
+  // the unix symlink() command reverses its parameters where the dst if
+  // first, so we follow suit here
   stream.PutCStringAsRawHex8(path.c_str());
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
@@ -3163,7 +3167,8 @@
 }
 
 bool GDBRemoteCommunicationClient::AvoidGPackets(ProcessGDBRemote *process) {
-  // Some targets have issues with g/G packets and we need to avoid using them
+  // Some targets have issues with g/G packets and we need to avoid using
+  // them
   if (m_avoid_g_packets == eLazyBoolCalculate) {
     if (process) {
       m_avoid_g_packets = eLazyBoolNo;
@@ -3275,9 +3280,8 @@
 bool GDBRemoteCommunicationClient::RestoreRegisterState(lldb::tid_t tid,
                                                         uint32_t save_id) {
   // We use the "m_supports_QSaveRegisterState" variable here because the
-  // QSaveRegisterState and QRestoreRegisterState packets must both be supported
-  // in
-  // order to be useful
+  // QSaveRegisterState and QRestoreRegisterState packets must both be
+  // supported in order to be useful
   if (m_supports_QSaveRegisterState == eLazyBoolNo)
     return false;
 
@@ -3638,7 +3642,8 @@
   payload.PutEscapedBytes(unescaped_payload.GetString().data(),
                           unescaped_payload.GetSize());
 
-  // Increase the timeout for jModulesInfo since this packet can take longer.
+  // Increase the timeout for jModulesInfo since this packet can take
+  // longer.
   ScopedTimeout timeout(*this, std::chrono::seconds(10));
 
   StringExtractorGDBRemote response;
@@ -3781,10 +3786,9 @@
 
 void GDBRemoteCommunicationClient::ServeSymbolLookups(
     lldb_private::Process *process) {
-  // Set to true once we've resolved a symbol to an address for the remote stub.
-  // If we get an 'OK' response after this, the remote stub doesn't need any
-  // more
-  // symbols and we can stop asking.
+  // Set to true once we've resolved a symbol to an address for the remote
+  // stub. If we get an 'OK' response after this, the remote stub doesn't
+  // need any more symbols and we can stop asking.
   bool symbol_response_provided = false;
 
   // Is this the initial qSymbol:: packet?
@@ -3809,8 +3813,8 @@
         first_qsymbol_query = false;
 
         if (response.IsUnsupportedResponse()) {
-          // qSymbol is not supported by the current GDB server we are connected
-          // to
+          // qSymbol is not supported by the current GDB server we are
+          // connected to
           m_supports_qSymbol = false;
           return;
         } else {
@@ -3874,13 +3878,12 @@
                   }
                 }
               }
-              // This is the normal path where our symbol lookup was successful
-              // and we want
-              // to send a packet with the new symbol value and see if another
-              // lookup needs to be
-              // done.
+              // This is the normal path where our symbol lookup was
+              // successful and we want to send a packet with the new
+              // symbol value and see if another lookup needs to be done.
 
-              // Change "packet" to contain the requested symbol value and name
+              // Change "packet" to contain the requested symbol value and
+              // name
               packet.Clear();
               packet.PutCString("qSymbol:");
               if (symbol_load_addr != LLDB_INVALID_ADDRESS) {
@@ -3897,8 +3900,8 @@
           }
         }
       }
-      // If we make it here, the symbol request packet response wasn't valid or
-      // our symbol lookup failed so we must abort
+      // If we make it here, the symbol request packet response wasn't
+      // valid or our symbol lookup failed so we must abort
       return;
 
     } else if (Log *log = ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(
@@ -3928,8 +3931,8 @@
           StructuredData::ParseJSON(response.GetStringRef());
       if (m_supported_async_json_packets_sp &&
           !m_supported_async_json_packets_sp->GetAsArray()) {
-        // We were returned something other than a JSON array.  This
-        // is invalid.  Clear it out.
+        // We were returned something other than a JSON array.  This is
+        // invalid.  Clear it out.
         if (log)
           log->Printf("GDBRemoteCommunicationClient::%s(): "
                       "QSupportedAsyncJSONPackets returned invalid "
@@ -3987,8 +3990,7 @@
     return error;
   }
 
-  // Build command: Configure{type_name}: serialized config
-  // data.
+  // Build command: Configure{type_name}: serialized config data.
   StreamGDBRemote stream;
   stream.PutCString("QConfigure");
   stream.PutCString(type_name.AsCString());
Index: source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp
===================================================================
--- source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp
+++ source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp
@@ -232,8 +232,8 @@
     response.PutCString("ostype:ios;");
 #endif
 
-    // On arm, we use "synchronous" watchpoints which means the exception is
-    // delivered before the instruction executes.
+    // On arm, we use "synchronous" watchpoints which means the exception
+    // is delivered before the instruction executes.
     response.PutCString("watchpoint_exceptions_received:before;");
   } else {
     response.PutCString("ostype:macosx;");
@@ -299,9 +299,9 @@
 #if defined(__APPLE__)
 
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
-  // For iOS devices, we are connected through a USB Mux so we never pretend
-  // to actually have a hostname as far as the remote lldb that is connecting
-  // to this lldb-platform is concerned
+  // For iOS devices, we are connected through a USB Mux so we never
+  // pretend to actually have a hostname as far as the remote lldb that is
+  // connecting to this lldb-platform is concerned
   response.PutCString("hostname:");
   response.PutCStringAsRawHex8("127.0.0.1");
   response.PutChar(';');
@@ -733,8 +733,8 @@
   packet.GetHexByteStringTerminatedBy(path, ',');
   if (!path.empty()) {
     if (packet.GetChar() == ',') {
-      // FIXME: add timeout to qPlatform_shell packet
-      // uint32_t timeout = packet.GetHexMaxU32(false, 32);
+      // FIXME: add timeout to qPlatform_shell packet uint32_t timeout =
+      // packet.GetHexMaxU32(false, 32);
       uint32_t timeout = 10;
       if (packet.GetChar() == ',')
         packet.GetHexByteString(working_dir);
@@ -987,8 +987,8 @@
   // The 'A' packet is the most over designed packet ever here with
   // redundant argument indexes, redundant argument lengths and needed hex
   // encoded argument string values. Really all that is needed is a comma
-  // separated hex encoded argument value list, but we will stay true to the
-  // documented version of the 'A' packet here...
+  // separated hex encoded argument value list, but we will stay true to
+  // the documented version of the 'A' packet here...
 
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
   int actual_arg_index = 0;
@@ -1006,8 +1006,8 @@
       if (packet.GetChar() != ',')
         success = false;
       else {
-        // Decode the argument index. We ignore this really because
-        // who would really send down the arguments in a random order???
+        // Decode the argument index. We ignore this really because who
+        // would really send down the arguments in a random order???
         const uint32_t arg_idx = packet.GetU32(UINT32_MAX);
         if (arg_idx == UINT32_MAX)
           success = false;
@@ -1016,9 +1016,9 @@
           if (packet.GetChar() != ',')
             success = false;
           else {
-            // Decode the argument string value from hex bytes
-            // back into a UTF8 string and make sure the length
-            // matches the one supplied in the packet
+            // Decode the argument string value from hex bytes back into a
+            // UTF8 string and make sure the length matches the one
+            // supplied in the packet
             std::string arg;
             if (packet.GetHexByteStringFixedLength(arg, arg_len) !=
                 (arg_len / 2))
@@ -1257,8 +1257,8 @@
       // Nothing.
       break;
     }
-    // In case of MIPS64, pointer size is depend on ELF ABI
-    // For N32 the pointer size is 4 and for N64 it is 8
+    // In case of MIPS64, pointer size is depend on ELF ABI For N32 the
+    // pointer size is 4 and for N64 it is 8
     std::string abi = proc_arch.GetTargetABI();
     if (!abi.empty())
       response.Printf("elf_abi:%s;", abi.c_str());
Index: source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
===================================================================
--- source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
+++ source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
@@ -236,16 +236,16 @@
     m_debugged_process_up = std::move(*process_or);
   }
 
-  // Handle mirroring of inferior stdout/stderr over the gdb-remote protocol
-  // as needed.
-  // llgs local-process debugging may specify PTY paths, which will make these
-  // file actions non-null
-  // process launch -i/e/o will also make these file actions non-null
-  // nullptr means that the traffic is expected to flow over gdb-remote protocol
+  // Handle mirroring of inferior stdout/stderr over the gdb-remote
+  // protocol as needed. llgs local-process debugging may specify PTY
+  // paths, which will make these file actions non-null process launch
+  // -i/e/o will also make these file actions non-null nullptr means that
+  // the traffic is expected to flow over gdb-remote protocol
   if (should_forward_stdio) {
-    // nullptr means it's not redirected to file or pty (in case of LLGS local)
-    // at least one of stdio will be transferred pty<->gdb-remote
-    // we need to give the pty master handle to this object to read and/or write
+    // nullptr means it's not redirected to file or pty (in case of LLGS
+    // local) at least one of stdio will be transferred pty<->gdb-remote
+    // we need to give the pty master handle to this object to read and/or
+    // write
     LLDB_LOG(log,
              "pid = {0}: setting up stdout/stderr redirection via $O "
              "gdb-remote commands",
@@ -287,8 +287,8 @@
     log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64,
                 __FUNCTION__, pid);
 
-  // Before we try to attach, make sure we aren't already monitoring something
-  // else.
+  // Before we try to attach, make sure we aren't already monitoring
+  // something else.
   if (m_debugged_process_up &&
       m_debugged_process_up->GetID() != LLDB_INVALID_PROCESS_ID)
     return Status("cannot attach to process %" PRIu64
@@ -410,8 +410,8 @@
   JSONObject::SP register_object_sp = std::make_shared<JSONObject>();
 
 #ifdef LLDB_JTHREADSINFO_FULL_REGISTER_SET
-  // Expedite all registers in the first register set (i.e. should be GPRs) that
-  // are not contained in other registers.
+  // Expedite all registers in the first register set (i.e. should be
+  // GPRs) that are not contained in other registers.
   const RegisterSet *reg_set_p = reg_ctx_sp->GetRegisterSet(0);
   if (!reg_set_p)
     return nullptr;
@@ -420,8 +420,7 @@
     uint32_t reg_num = *reg_num_p;
 #else
   // Expedite only a couple of registers until we figure out why sending
-  // registers is
-  // expensive.
+  // registers is expensive.
   static const uint32_t k_expedited_registers[] = {
       LLDB_REGNUM_GENERIC_PC, LLDB_REGNUM_GENERIC_SP, LLDB_REGNUM_GENERIC_FP,
       LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM};
@@ -594,9 +593,8 @@
   if (!thread->GetStopReason(tid_stop_info, description))
     return SendErrorResponse(52);
 
-  // FIXME implement register handling for exec'd inferiors.
-  // if (tid_stop_info.reason == eStopReasonExec)
-  // {
+  // FIXME implement register handling for exec'd inferiors. if
+  // (tid_stop_info.reason == eStopReasonExec) {
   //     const bool force = true;
   //     InitializeRegisters(force);
   // }
@@ -634,13 +632,13 @@
   }
 
   // If a 'QListThreadsInStopReply' was sent to enable this feature, we
-  // will send all thread IDs back in the "threads" key whose value is
-  // a list of hex thread IDs separated by commas:
+  // will send all thread IDs back in the "threads" key whose value is a
+  // list of hex thread IDs separated by commas:
   //  "threads:10a,10b,10c;"
-  // This will save the debugger from having to send a pair of qfThreadInfo
-  // and qsThreadInfo packets, but it also might take a lot of room in the
-  // stop reply packet, so it must be enabled only on systems where there
-  // are no limits on packet lengths.
+  // This will save the debugger from having to send a pair of
+  // qfThreadInfo and qsThreadInfo packets, but it also might take a lot
+  // of room in the stop reply packet, so it must be enabled only on
+  // systems where there are no limits on packet lengths.
   if (m_list_threads_in_stop_reply) {
     response.PutCString("threads:");
 
@@ -657,10 +655,10 @@
 
     // Include JSON info that describes the stop reason for any threads
     // that actually have stop reasons. We use the new "jstopinfo" key
-    // whose values is hex ascii JSON that contains the thread IDs
-    // thread stop info only for threads that have stop reasons. Only send
-    // this if we have more than one thread otherwise this packet has all
-    // the info it needs.
+    // whose values is hex ascii JSON that contains the thread IDs thread
+    // stop info only for threads that have stop reasons. Only send this
+    // if we have more than one thread otherwise this packet has all the
+    // info it needs.
     if (thread_index > 0) {
       const bool threads_with_valid_stop_info_only = true;
       JSONArray::SP threads_info_sp = GetJSONThreadsInfo(
@@ -716,8 +714,8 @@
 
   // Grab the register context.
   NativeRegisterContext& reg_ctx = thread->GetRegisterContext();
-  // Expedite all registers in the first register set (i.e. should be GPRs)
-  // that are not contained in other registers.
+  // Expedite all registers in the first register set (i.e. should be
+  // GPRs) that are not contained in other registers.
   const RegisterSet *reg_set_p;
   if (reg_ctx.GetRegisterSetCount() > 0 &&
       ((reg_set_p = reg_ctx.GetRegisterSet(0)) != nullptr)) {
@@ -741,7 +739,8 @@
                       reg_set_p->name ? reg_set_p->name : "<unnamed-set>",
                       *reg_num_p);
       } else if (reg_info_p->value_regs == nullptr) {
-        // Only expediate registers that are not contained in other registers.
+        // Only expediate registers that are not contained in other
+        // registers.
         RegisterValue reg_value;
         Status error = reg_ctx.ReadRegister(reg_info_p, reg_value);
         if (error.Success()) {
@@ -806,8 +805,8 @@
                   __FUNCTION__, process->GetID());
   }
 
-  // Close the pipe to the inferior terminal i/o if we launched it
-  // and set one up.
+  // Close the pipe to the inferior terminal i/o if we launched it and set
+  // one up.
   MaybeCloseInferiorTerminalConnection();
 
   // We are ready to exit the debug monitor.
@@ -823,8 +822,8 @@
   if (log)
     log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
 
-  // Send the stop reason unless this is the stop after the
-  // launch or attach.
+  // Send the stop reason unless this is the stop after the launch or
+  // attach.
   switch (m_inferior_prev_state) {
   case eStateLaunching:
   case eStateAttaching:
@@ -863,9 +862,8 @@
     // and send it to the lldb host before we send the state change
     // notification
     SendProcessOutput();
-    // Then stop the forwarding, so that any late output (see llvm.org/pr25652)
-    // does not
-    // interfere with our protocol.
+    // Then stop the forwarding, so that any late output (see
+    // llvm.org/pr25652) does not interfere with our protocol.
     StopSTDIOForwarding();
     HandleInferiorState_Stopped(process);
     break;
@@ -1287,8 +1285,8 @@
       (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
     return SendErrorResponse(68);
 
-  // Make sure we set the current thread so g and p packets return
-  // the data the gdb will expect.
+  // Make sure we set the current thread so g and p packets return the
+  // data the gdb will expect.
   lldb::tid_t tid = m_debugged_process_up->GetCurrentThreadID();
   SetCurrentThreadID(tid);
 
@@ -1385,7 +1383,8 @@
 
   // Handle optional continue address.
   if (packet.GetBytesLeft() > 0) {
-    // FIXME add continue at address support for $C{signo}[;{continue-address}].
+    // FIXME add continue at address support for $C{signo}[;{continue-
+    // address}].
     if (*packet.Peek() == ';')
       return SendUnimplementedResponse(packet.GetStringRef().c_str());
     else
@@ -1396,27 +1395,26 @@
   ResumeActionList resume_actions(StateType::eStateRunning, 0);
   Status error;
 
-  // We have two branches: what to do if a continue thread is specified (in
-  // which case we target
-  // sending the signal to that thread), or when we don't have a continue thread
-  // set (in which
-  // case we send a signal to the process).
+  // We have two branches: what to do if a continue thread is specified
+  // (in which case we target sending the signal to that thread), or when
+  // we don't have a continue thread set (in which case we send a signal
+  // to the process).
 
   // TODO discuss with Greg Clayton, make sure this makes sense.
 
   lldb::tid_t signal_tid = GetContinueThreadID();
   if (signal_tid != LLDB_INVALID_THREAD_ID) {
-    // The resume action for the continue thread (or all threads if a continue
-    // thread is not set).
+    // The resume action for the continue thread (or all threads if a
+    // continue thread is not set).
     ResumeAction action = {GetContinueThreadID(), StateType::eStateRunning,
                            static_cast<int>(signo)};
 
-    // Add the action for the continue thread (or all threads when the continue
-    // thread isn't present).
+    // Add the action for the continue thread (or all threads when the
+    // continue thread isn't present).
     resume_actions.Append(action);
   } else {
-    // Send the signal to the process since we weren't targeting a specific
-    // continue thread with the signal.
+    // Send the signal to the process since we weren't targeting a
+    // specific continue thread with the signal.
     error = m_debugged_process_up->Signal(signo);
     if (error.Fail()) {
       LLDB_LOG(log, "failed to send signal for process {0}: {1}",
@@ -1631,16 +1629,16 @@
   case eStateRunning:
   case eStateStepping:
   case eStateDetached:
-    // NOTE: gdb protocol doc looks like it should return $OK
-    // when everything is running (i.e. no stopped result).
+    // NOTE: gdb protocol doc looks like it should return $OK when
+    // everything is running (i.e. no stopped result).
     return PacketResult::Success; // Ignore
 
   case eStateSuspended:
   case eStateStopped:
   case eStateCrashed: {
     lldb::tid_t tid = m_debugged_process_up->GetCurrentThreadID();
-    // Make sure we set the current thread so g and p packets return
-    // the data the gdb will expect.
+    // Make sure we set the current thread so g and p packets return the
+    // data the gdb will expect.
     SetCurrentThreadID(tid);
     return SendStopReplyPacketForThread(tid);
   }
@@ -1682,8 +1680,8 @@
   if (reg_index == std::numeric_limits<uint32_t>::max())
     return SendErrorResponse(69);
 
-  // Return the end of registers response if we've iterated one past the end of
-  // the register set.
+  // Return the end of registers response if we've iterated one past the
+  // end of the register set.
   if (reg_index >= reg_context.GetUserRegisterCount())
     return SendErrorResponse(69);
 
@@ -1901,8 +1899,8 @@
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo(
     StringExtractorGDBRemote &packet) {
-  // FIXME for now we return the full thread list in the initial packet and
-  // always do nothing here.
+  // FIXME for now we return the full thread list in the initial packet
+  // and always do nothing here.
   return SendPacketNoLock("l");
 }
 
@@ -1932,8 +1930,8 @@
   // Get the thread's register context.
   NativeRegisterContext &reg_context = thread->GetRegisterContext();
 
-  // Return the end of registers response if we've iterated one past the end of
-  // the register set.
+  // Return the end of registers response if we've iterated one past the
+  // end of the register set.
   if (reg_index >= reg_context.GetUserRegisterCount()) {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
@@ -1976,7 +1974,8 @@
     return SendErrorResponse(0x15);
   }
 
-  // FIXME flip as needed to get data in big/little endian format for this host.
+  // FIXME flip as needed to get data in big/little endian format for this
+  // host.
   for (uint32_t i = 0; i < reg_value.GetByteSize(); ++i)
     response.PutHex8(data[i]);
 
@@ -2033,8 +2032,8 @@
     return SendErrorResponse(0x48);
   }
 
-  // Return the end of registers response if we've iterated one past the end of
-  // the register set.
+  // Return the end of registers response if we've iterated one past the
+  // end of the register set.
   if (reg_index >= reg_context.GetUserRegisterCount()) {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
@@ -2043,9 +2042,9 @@
     return SendErrorResponse(0x47);
   }
 
-  // The dwarf expression are evaluate on host site
-  // which may cause register size to change
-  // Hence the reg_size may not be same as reg_info->bytes_size
+  // The dwarf expression are evaluate on host site which may cause
+  // register size to change Hence the reg_size may not be same as
+  // reg_info->bytes_size
   if ((reg_size != reg_info->byte_size) &&
       !(reg_info->dynamic_size_dwarf_expr_bytes)) {
     return SendIllFormedResponse(packet, "P packet register size is incorrect");
@@ -2115,8 +2114,8 @@
   const lldb::tid_t tid =
       packet.GetHexMaxU64(false, std::numeric_limits<lldb::tid_t>::max());
 
-  // Ensure we have the given thread when not specifying -1 (all threads) or 0
-  // (any thread).
+  // Ensure we have the given thread when not specifying -1 (all threads)
+  // or 0 (any thread).
   if (tid != LLDB_INVALID_THREAD_ID && tid != 0) {
     NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid);
     if (!thread) {
@@ -2227,9 +2226,8 @@
   if (packet.GetBytesLeft() < 1)
     return SendIllFormedResponse(packet, "Too short m packet");
 
-  // Read the address.  Punting on validation.
-  // FIXME replace with Hex U64 read with no default value that fails on failed
-  // read.
+  // Read the address.  Punting on validation. FIXME replace with Hex U64
+  // read with no default value that fails on failed read.
   const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0);
 
   // Validate comma.
@@ -2308,9 +2306,8 @@
   if (packet.GetBytesLeft() < 1)
     return SendIllFormedResponse(packet, "Too short M packet");
 
-  // Read the address.  Punting on validation.
-  // FIXME replace with Hex U64 read with no default value that fails on failed
-  // read.
+  // Read the address.  Punting on validation. FIXME replace with Hex U64
+  // read with no default value that fails on failed read.
   const lldb::addr_t write_addr = packet.GetHexMaxU64(false, 0);
 
   // Validate comma.
@@ -2376,10 +2373,9 @@
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   // Currently only the NativeProcessProtocol knows if it can handle a
-  // qMemoryRegionInfoSupported
-  // request, but we're not guaranteed to be attached to a process.  For now
-  // we'll assume the
-  // client only asks this when a process is being debugged.
+  // qMemoryRegionInfoSupported request, but we're not guaranteed to be
+  // attached to a process.  For now we'll assume the client only asks
+  // this when a process is being debugged.
 
   // Ensure we have a process running; otherwise, we can't figure this out
   // since we won't have a NativeProcessProtocol.
@@ -2392,7 +2388,8 @@
     return SendErrorResponse(0x15);
   }
 
-  // Test if we can get any region back when asking for the region around NULL.
+  // Test if we can get any region back when asking for the region around
+  // NULL.
   MemoryRegionInfo region_info;
   const Status error =
       m_debugged_process_up->GetMemoryRegionInfo(0, region_info);
@@ -2669,17 +2666,16 @@
     return SendErrorResponse(0x32);
   }
 
-  // We first try to use a continue thread id.  If any one or any all set, use
-  // the current thread.
-  // Bail out if we don't have a thread id.
+  // We first try to use a continue thread id.  If any one or any all set,
+  // use the current thread. Bail out if we don't have a thread id.
   lldb::tid_t tid = GetContinueThreadID();
   if (tid == 0 || tid == LLDB_INVALID_THREAD_ID)
     tid = GetCurrentThreadID();
   if (tid == LLDB_INVALID_THREAD_ID)
     return SendErrorResponse(0x33);
 
-  // Double check that we have such a thread.
-  // TODO investigate: on MacOSX we might need to do an UpdateThreads () here.
+  // Double check that we have such a thread. TODO investigate: on MacOSX
+  // we might need to do an UpdateThreads () here.
   NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid);
   if (!thread)
     return SendErrorResponse(0x33);
@@ -2703,7 +2699,8 @@
     return SendErrorResponse(0x49);
   }
 
-  // No response here - the stop or exit will come from the resulting action.
+  // No response here - the stop or exit will come from the resulting
+  // action.
   return PacketResult::Success;
 }
 
@@ -2769,11 +2766,12 @@
     response.PutChar('l');
     done_with_buffer = true;
   } else {
-    // Figure out how many bytes are available starting at the given offset.
+    // Figure out how many bytes are available starting at the given
+    // offset.
     buffer = buffer.drop_front(auxv_offset);
 
-    // Mark the response type according to whether we're reading the remainder
-    // of the auxv data.
+    // Mark the response type according to whether we're reading the
+    // remainder of the auxv data.
     if (auxv_length >= buffer.size()) {
       // There will be nothing left to read after this
       response.PutChar('l');
@@ -3153,9 +3151,8 @@
       m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)
     return nullptr;
 
-  // If the client hasn't asked for thread suffix support, there will not be a
-  // thread suffix.
-  // Use the current thread in that case.
+  // If the client hasn't asked for thread suffix support, there will not
+  // be a thread suffix. Use the current thread in that case.
   if (!m_thread_suffix_supported) {
     const lldb::tid_t current_tid = GetCurrentThreadID();
     if (current_tid == LLDB_INVALID_THREAD_ID)
@@ -3201,9 +3198,9 @@
 
 lldb::tid_t GDBRemoteCommunicationServerLLGS::GetCurrentThreadID() const {
   if (m_current_tid == 0 || m_current_tid == LLDB_INVALID_THREAD_ID) {
-    // Use whatever the debug process says is the current thread id
-    // since the protocol either didn't specify or specified we want
-    // any/all threads marked as the current thread.
+    // Use whatever the debug process says is the current thread id since
+    // the protocol either didn't specify or specified we want any/all
+    // threads marked as the current thread.
     if (!m_debugged_process_up)
       return LLDB_INVALID_THREAD_ID;
     return m_debugged_process_up->GetCurrentThreadID();
Index: source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp
===================================================================
--- source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp
+++ source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp
@@ -102,8 +102,8 @@
   if (port == UINT16_MAX)
     port = GetNextAvailablePort();
 
-  // Spawn a new thread to accept the port that gets bound after
-  // binding to port 0 (zero).
+  // Spawn a new thread to accept the port that gets bound after binding
+  // to port 0 (zero).
 
   // ignore the hostname send from the remote end, just use the ip address
   // that we're currently communicating with as the hostname
@@ -171,8 +171,8 @@
 #ifdef _WIN32
   return SendErrorResponse(9);
 #else
-  // Spawn a local debugserver as a platform so we can then attach or launch
-  // a process...
+  // Spawn a local debugserver as a platform so we can then attach or
+  // launch a process...
 
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
   if (log)
@@ -260,8 +260,7 @@
 
   lldb::pid_t pid = packet.GetU64(LLDB_INVALID_PROCESS_ID);
 
-  // verify that we know anything about this pid.
-  // Scope for locker
+  // verify that we know anything about this pid. Scope for locker
   {
     std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
     if (m_spawned_pids.find(pid) == m_spawned_pids.end()) {
@@ -307,8 +306,8 @@
       return true;
   }
 
-  // the launched process still lives.  Now try killing it again,
-  // this time with an unblockable signal.
+  // the launched process still lives.  Now try killing it again, this
+  // time with an unblockable signal.
   Host::Kill(pid, SIGKILL);
 
   for (size_t i = 0; i < 10; ++i) {
@@ -322,8 +321,7 @@
     usleep(10000);
   }
 
-  // check one more time after the final usleep
-  // Scope for locker
+  // check one more time after the final usleep Scope for locker
   {
     std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
     if (m_spawned_pids.find(pid) == m_spawned_pids.end())
@@ -380,11 +378,10 @@
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerPlatform::Handle_qC(
     StringExtractorGDBRemote &packet) {
-  // NOTE: lldb should now be using qProcessInfo for process IDs.  This path
-  // here
-  // should not be used.  It is reporting process id instead of thread id.  The
-  // correct answer doesn't seem to make much sense for lldb-platform.
-  // CONSIDER: flip to "unsupported".
+  // NOTE: lldb should now be using qProcessInfo for process IDs.  This
+  // path here should not be used.  It is reporting process id instead of
+  // thread id.  The correct answer doesn't seem to make much sense for
+  // lldb-platform. CONSIDER: flip to "unsupported".
   lldb::pid_t pid = m_process_launch_info.GetProcessID();
 
   StreamString response;
@@ -447,8 +444,7 @@
                   __FUNCTION__);
 
   // specify the process monitor if not already set.  This should
-  // generally be what happens since we need to reap started
-  // processes.
+  // generally be what happens since we need to reap started processes.
   if (!m_process_launch_info.GetMonitorProcessCallback())
     m_process_launch_info.SetMonitorProcessCallback(
         std::bind(
@@ -467,8 +463,8 @@
          m_process_launch_info.GetArguments().GetArgumentAtIndex(0),
          m_process_launch_info.GetProcessID());
 
-  // add to list of spawned processes.  On an lldb-gdbserver, we
-  // would expect there to be only one.
+  // add to list of spawned processes.  On an lldb-gdbserver, we would
+  // expect there to be only one.
   const auto pid = m_process_launch_info.GetProcessID();
   if (pid != LLDB_INVALID_PROCESS_ID) {
     // add to spawned pids
Index: source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
===================================================================
--- source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
+++ source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
@@ -39,9 +39,9 @@
     GDBRemoteDynamicRegisterInfo &reg_info, bool read_all_at_once)
     : RegisterContext(thread, concrete_frame_idx), m_reg_info(reg_info),
       m_reg_valid(), m_reg_data(), m_read_all_at_once(read_all_at_once) {
-  // Resize our vector of bools to contain one bool for every register.
-  // We will use these boolean values to know when a register value
-  // is valid in m_reg_data.
+  // Resize our vector of bools to contain one bool for every register. We
+  // will use these boolean values to know when a register value is valid
+  // in m_reg_data.
   m_reg_valid.resize(reg_info.GetNumRegisters());
 
   // Make a heap based buffer that is big enough to store all registers
@@ -132,12 +132,10 @@
   if (reg_info == NULL)
     return false;
 
-  // Early in process startup, we can get a thread that has an invalid byte
-  // order
-  // because the process hasn't been completely set up yet (see the ctor where
-  // the
-  // byte order is setfrom the process).  If that's the case, we can't set the
-  // value here.
+  // Early in process startup, we can get a thread that has an invalid
+  // byte order because the process hasn't been completely set up yet (see
+  // the ctor where the byte order is setfrom the process).  If that's the
+  // case, we can't set the value here.
   if (m_reg_data.GetByteOrder() == eByteOrderInvalid) {
     return false;
   }
@@ -148,9 +146,8 @@
   DataBufferSP buffer_sp(new DataBufferHeap(&new_reg_val, sizeof(new_reg_val)));
   DataExtractor data(buffer_sp, endian::InlHostByteOrder(), sizeof(void *));
 
-  // If our register context and our register info disagree, which should never
-  // happen, don't
-  // overwrite past the end of the buffer.
+  // If our register context and our register info disagree, which should
+  // never happen, don't overwrite past the end of the buffer.
   if (m_reg_data.GetByteSize() < reg_info->byte_offset + reg_info->byte_size)
     return false;
 
@@ -219,8 +216,7 @@
     }
     if (reg_info->value_regs) {
       // Process this composite register request by delegating to the
-      // constituent
-      // primordial registers.
+      // constituent primordial registers.
 
       // Index of the primordial register.
       bool success = true;
@@ -228,8 +224,8 @@
         const uint32_t prim_reg = reg_info->value_regs[idx];
         if (prim_reg == LLDB_INVALID_REGNUM)
           break;
-        // We have a valid primordial register as our constituent.
-        // Grab the corresponding register info.
+        // We have a valid primordial register as our constituent. Grab
+        // the corresponding register info.
         const RegisterInfo *prim_reg_info = GetRegisterInfoAtIndex(prim_reg);
         if (prim_reg_info == NULL)
           success = false;
@@ -242,8 +238,7 @@
 
       if (success) {
         // If we reach this point, all primordial register requests have
-        // succeeded.
-        // Validate this composite register.
+        // succeeded. Validate this composite register.
         SetRegisterIsValid(reg_info, true);
       }
     } else {
@@ -261,16 +256,14 @@
     assert(m_reg_data.GetByteSize() >=
            reg_info->byte_offset + reg_info->byte_size);
 #endif
-    // If our register context and our register info disagree, which should
-    // never happen, don't
-    // read past the end of the buffer.
+    // If our register context and our register info disagree, which
+    // should never happen, don't read past the end of the buffer.
     if (m_reg_data.GetByteSize() < reg_info->byte_offset + reg_info->byte_size)
       return false;
 
-    // If we aren't extracting into our own buffer (which
-    // only happens when this function is called from
-    // ReadRegisterValue(uint32_t, Scalar&)) then
-    // we transfer bytes from our buffer into the data
+    // If we aren't extracting into our own buffer (which only happens
+    // when this function is called from ReadRegisterValue(uint32_t,
+    // Scalar&)) then we transfer bytes from our buffer into the data
     // buffer that was passed in
 
     data.SetByteOrder(m_reg_data.GetByteOrder());
@@ -320,9 +313,8 @@
          reg_info->byte_offset + reg_info->byte_size);
 #endif
 
-  // If our register context and our register info disagree, which should never
-  // happen, don't
-  // overwrite past the end of the buffer.
+  // If our register context and our register info disagree, which should
+  // never happen, don't overwrite past the end of the buffer.
   if (m_reg_data.GetByteSize() < reg_info->byte_offset + reg_info->byte_size)
     return false;
 
@@ -358,12 +350,10 @@
         bool success = true;
 
         if (reg_info->value_regs) {
-          // This register is part of another register. In this case we read the
-          // actual
-          // register data for any "value_regs", and once all that data is read,
-          // we will
-          // have enough data in our register context bytes for the value of
-          // this register
+          // This register is part of another register. In this case we
+          // read the actual register data for any "value_regs", and once
+          // all that data is read, we will have enough data in our
+          // register context bytes for the value of this register
 
           // Invalidate this composite register first.
 
@@ -384,9 +374,8 @@
           success = SetPrimordialRegister(reg_info, gdb_comm);
         }
 
-        // Check if writing this register will invalidate any other register
-        // values?
-        // If so, invalidate them
+        // Check if writing this register will invalidate any other
+        // register values? If so, invalidate them
         if (reg_info->invalidate_regs) {
           for (uint32_t idx = 0, reg = reg_info->invalidate_regs[0];
                reg != LLDB_INVALID_REGNUM;
@@ -548,27 +537,24 @@
         return true;
 
       uint32_t num_restored = 0;
-      // We need to manually go through all of the registers and
-      // restore them manually
+      // We need to manually go through all of the registers and restore
+      // them manually
       DataExtractor restore_data(data_sp, m_reg_data.GetByteOrder(),
                                  m_reg_data.GetAddressByteSize());
 
       const RegisterInfo *reg_info;
 
-      // The g packet contents may either include the slice registers (registers
-      // defined in
-      // terms of other registers, e.g. eax is a subset of rax) or not.  The
-      // slice registers
-      // should NOT be in the g packet, but some implementations may incorrectly
-      // include them.
+      // The g packet contents may either include the slice registers
+      // (registers defined in terms of other registers, e.g. eax is a
+      // subset of rax) or not.  The slice registers should NOT be in the
+      // g packet, but some implementations may incorrectly include them.
       //
-      // If the slice registers are included in the packet, we must step over
-      // the slice registers
-      // when parsing the packet -- relying on the RegisterInfo byte_offset
-      // field would be incorrect.
-      // If the slice registers are not included, then using the byte_offset
-      // values into the
-      // data buffer is the best way to find individual register values.
+      // If the slice registers are included in the packet, we must step
+      // over the slice registers when parsing the packet -- relying on
+      // the RegisterInfo byte_offset field would be incorrect. If the
+      // slice registers are not included, then using the byte_offset
+      // values into the data buffer is the best way to find individual
+      // register values.
 
       uint64_t size_including_slice_registers = 0;
       uint64_t size_not_including_slice_registers = 0;
@@ -585,37 +571,35 @@
 
       bool use_byte_offset_into_buffer;
       if (size_by_highest_offset == restore_data.GetByteSize()) {
-        // The size of the packet agrees with the highest offset: + size in the
-        // register file
+        // The size of the packet agrees with the highest offset: + size
+        // in the register file
         use_byte_offset_into_buffer = true;
       } else if (size_not_including_slice_registers ==
                  restore_data.GetByteSize()) {
         // The size of the packet is the same as concatenating all of the
-        // registers sequentially,
-        // skipping the slice registers
+        // registers sequentially, skipping the slice registers
         use_byte_offset_into_buffer = true;
       } else if (size_including_slice_registers == restore_data.GetByteSize()) {
-        // The slice registers are present in the packet (when they shouldn't
-        // be).
-        // Don't try to use the RegisterInfo byte_offset into the restore_data,
-        // it will
-        // point to the wrong place.
+        // The slice registers are present in the packet (when they
+        // shouldn't be). Don't try to use the RegisterInfo byte_offset
+        // into the restore_data, it will point to the wrong place.
         use_byte_offset_into_buffer = false;
       } else {
         // None of our expected sizes match the actual g packet data we're
-        // looking at.
-        // The most conservative approach here is to use the running total byte
-        // offset.
+        // looking at. The most conservative approach here is to use the
+        // running total byte offset.
         use_byte_offset_into_buffer = false;
       }
 
-      // In case our register definitions don't include the correct offsets,
-      // keep track of the size of each reg & compute offset based on that.
+      // In case our register definitions don't include the correct
+      // offsets, keep track of the size of each reg & compute offset
+      // based on that.
       uint32_t running_byte_offset = 0;
       for (uint32_t reg_idx = 0;
            (reg_info = GetRegisterInfoAtIndex(reg_idx)) != NULL;
            ++reg_idx, running_byte_offset += reg_info->byte_size) {
-        // Skip composite aka slice registers (e.g. eax is a slice of rax).
+        // Skip composite aka slice registers (e.g. eax is a slice of
+        // rax).
         if (reg_info->value_regs)
           continue;
 
@@ -643,9 +627,9 @@
       }
       return num_restored > 0;
     } else {
-      // For the use_g_packet == false case, we're going to write each register
-      // individually.  The data buffer is binary data in this case, instead of
-      // ascii characters.
+      // For the use_g_packet == false case, we're going to write each
+      // register individually.  The data buffer is binary data in this
+      // case, instead of ascii characters.
 
       bool arm64_debugserver = false;
       if (m_thread.GetProcess().get()) {
@@ -664,11 +648,10 @@
         if (reg_info->value_regs) // skip registers that are slices of real
                                   // registers
           continue;
-        // Skip the fpsr and fpcr floating point status/control register writing
-        // to
-        // work around a bug in an older version of debugserver that would lead
-        // to
-        // register context corruption when writing fpsr/fpcr.
+        // Skip the fpsr and fpcr floating point status/control register
+        // writing to work around a bug in an older version of debugserver
+        // that would lead to register context corruption when writing
+        // fpsr/fpcr.
         if (arm64_debugserver && (strcmp(reg_info->name, "fpsr") == 0 ||
                                   strcmp(reg_info->name, "fpcr") == 0)) {
           continue;
@@ -752,8 +735,8 @@
   static uint32_t g_q14_regs[] = {71, 72, LLDB_INVALID_REGNUM}; // (d28, d29)
   static uint32_t g_q15_regs[] = {73, 74, LLDB_INVALID_REGNUM}; // (d30, d31)
 
-  // This is our array of composite registers, with each element coming from the
-  // above register mappings.
+  // This is our array of composite registers, with each element coming
+  // from the above register mappings.
   static uint32_t *g_composites[] = {
       g_d0_regs,  g_d1_regs,  g_d2_regs,  g_d3_regs,  g_d4_regs,  g_d5_regs,
       g_d6_regs,  g_d7_regs,  g_d8_regs,  g_d9_regs,  g_d10_regs, g_d11_regs,
@@ -883,22 +866,19 @@
   size_t i;
   if (from_scratch) {
     // Calculate the offsets of the registers
-    // Note that the layout of the "composite" registers (d0-d15 and q0-q15)
-    // which comes after the
-    // "primordial" registers is important.  This enables us to calculate the
-    // offset of the composite
-    // register by using the offset of its first primordial register.  For
-    // example, to calculate the
-    // offset of q0, use s0's offset.
+    // Note that the layout of the "composite" registers (d0-d15 and
+    // q0-q15) which comes after the "primordial" registers is important.
+    // This enables us to calculate the offset of the composite register
+    // by using the offset of its first primordial register.  For example,
+    // to calculate the offset of q0, use s0's offset.
     if (g_register_infos[2].byte_offset == 0) {
       uint32_t byte_offset = 0;
       for (i = 0; i < num_registers; ++i) {
-        // For primordial registers, increment the byte_offset by the byte_size
-        // to arrive at the
-        // byte_offset for the next register.  Otherwise, we have a composite
-        // register whose
-        // offset can be calculated by consulting the offset of its first
-        // primordial register.
+        // For primordial registers, increment the byte_offset by the
+        // byte_size to arrive at the byte_offset for the next register.
+        // Otherwise, we have a composite register whose offset can be
+        // calculated by consulting the offset of its first primordial
+        // register.
         if (!g_register_infos[i].value_regs) {
           g_register_infos[i].byte_offset = byte_offset;
           byte_offset += g_register_infos[i].byte_size;
@@ -932,9 +912,9 @@
     const size_t num_common_regs = num_registers - num_composites;
     RegisterInfo *g_comp_register_infos = g_register_infos + num_common_regs;
 
-    // First we need to validate that all registers that we already have match
-    // the non composite regs.
-    // If so, then we can add the registers, else we need to bail
+    // First we need to validate that all registers that we already have
+    // match the non composite regs. If so, then we can add the registers,
+    // else we need to bail
     bool match = true;
     if (num_dynamic_regs == num_common_regs) {
       for (i = 0; match && i < num_dynamic_regs; ++i) {
@@ -970,9 +950,9 @@
             // Find a matching primordial register info entry.
             if (reg_info && reg_info->name &&
                 ::strcasecmp(reg_info->name, reg_name) == 0) {
-              // The name matches the existing primordial entry.
-              // Find and assign the offset, and then add this composite
-              // register entry.
+              // The name matches the existing primordial entry. Find and
+              // assign the offset, and then add this composite register
+              // entry.
               g_comp_register_infos[i].byte_offset = reg_info->byte_offset;
               name.SetCString(g_comp_register_infos[i].name);
               AddRegister(g_comp_register_infos[i], name, alt_name,
Index: source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
===================================================================
--- source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -94,11 +94,11 @@
 
 namespace lldb {
 // Provide a function that can easily dump the packet history if we know a
-// ProcessGDBRemote * value (which we can get from logs or from debugging).
-// We need the function in the lldb namespace so it makes it into the final
-// executable since the LLDB shared library only exports stuff in the lldb
-// namespace. This allows you to attach with a debugger and call this
-// function and get the packet history dumped to a file.
+// ProcessGDBRemote * value (which we can get from logs or from
+// debugging). We need the function in the lldb namespace so it makes it
+// into the final executable since the LLDB shared library only exports
+// stuff in the lldb namespace. This allows you to attach with a debugger
+// and call this function and get the packet history dumped to a file.
 void DumpProcessGDBRemotePacketHistory(void *p, const char *path) {
   StreamFile strm;
   Status error(strm.GetFile().Open(path, File::eOpenOptionWrite |
@@ -161,8 +161,8 @@
 } // anonymous namespace end
 
 // TODO Randomly assigning a port is unsafe.  We should get an unused
-// ephemeral port from the kernel and make sure we reserve it before passing
-// it to debugserver.
+// ephemeral port from the kernel and make sure we reserve it before
+// passing it to debugserver.
 
 #if defined(__APPLE__)
 #define LOW_PORT (IPPORT_RESERVED)
@@ -236,8 +236,8 @@
     }
     return exe_module->GetFileSpec().Exists();
   }
-  // However, if there is no executable module, we return true since we might be
-  // preparing to attach.
+  // However, if there is no executable module, we return true since we
+  // might be preparing to attach.
   return true;
 }
 
@@ -309,11 +309,10 @@
   // trying to fully destroy the broadcaster.
   Finalize();
 
-  // The general Finalize is going to try to destroy the process and that SHOULD
-  // shut down the async thread.  However, if we don't kill it it will get
-  // stranded and
-  // its connection will go away so when it wakes up it will crash.  So kill it
-  // for sure here.
+  // The general Finalize is going to try to destroy the process and that
+  // SHOULD shut down the async thread.  However, if we don't kill it it
+  // will get stranded and its connection will go away so when it wakes up
+  // it will crash.  So kill it for sure here.
   StopAsyncThread();
   KillDebugserverProcess();
 }
@@ -371,10 +370,9 @@
   return false;
 }
 
-// If the remote stub didn't give us eh_frame or DWARF register numbers for a
-// register,
-// see if the ABI can provide them.
-// DWARF and eh_frame register numbers are defined as a part of the ABI.
+// If the remote stub didn't give us eh_frame or DWARF register numbers
+// for a register, see if the ABI can provide them. DWARF and eh_frame
+// register numbers are defined as a part of the ABI.
 static void AugmentRegisterInfoViaABI(RegisterInfo &reg_info,
                                       ConstString reg_name, ABISP abi_sp) {
   if (reg_info.kinds[eRegisterKindEHFrame] == LLDB_INVALID_REGNUM ||
@@ -426,9 +424,9 @@
 
   m_register_info.Clear();
 
-  // Check if qHostInfo specified a specific packet timeout for this connection.
-  // If so then lets update our setting so the user knows what the timeout is
-  // and can see it.
+  // Check if qHostInfo specified a specific packet timeout for this
+  // connection. If so then lets update our setting so the user knows what
+  // the timeout is and can see it.
   const auto host_packet_timeout = m_gdb_comm.GetHostDefaultPacketTimeout();
   if (host_packet_timeout > std::chrono::seconds(0)) {
     GetGlobalPluginProperties()->SetPacketTimeout(host_packet_timeout.count());
@@ -443,8 +441,8 @@
   FileSpec target_definition_fspec =
       GetGlobalPluginProperties()->GetTargetDefinitionFile();
   if (!target_definition_fspec.Exists()) {
-    // If the filename doesn't exist, it may be a ~ not having been expanded -
-    // try to resolve it.
+    // If the filename doesn't exist, it may be a ~ not having been
+    // expanded - try to resolve it.
     target_definition_fspec.ResolvePath();
   }
   if (target_definition_fspec) {
@@ -599,11 +597,10 @@
           reg_info.invalidate_regs = invalidate_regs.data();
         }
 
-        // We have to make a temporary ABI here, and not use the GetABI because
-        // this code
-        // gets called in DidAttach, when the target architecture (and
-        // consequently the ABI we'll get from
-        // the process) may be wrong.
+        // We have to make a temporary ABI here, and not use the GetABI
+        // because this code gets called in DidAttach, when the target
+        // architecture (and consequently the ABI we'll get from the
+        // process) may be wrong.
         ABISP abi_to_use = ABI::FindPlugin(shared_from_this(), arch_to_use);
 
         AugmentRegisterInfoViaABI(reg_info, reg_name, abi_to_use);
@@ -622,11 +619,11 @@
     return;
   }
 
-  // We didn't get anything if the accumulated reg_num is zero.  See if we are
-  // debugging ARM and fill with a hard coded register set until we can get an
-  // updated debugserver down on the devices.
-  // On the other hand, if the accumulated reg_num is positive, see if we can
-  // add composite registers to the existing primordial ones.
+  // We didn't get anything if the accumulated reg_num is zero.  See if we
+  // are debugging ARM and fill with a hard coded register set until we
+  // can get an updated debugserver down on the devices. On the other
+  // hand, if the accumulated reg_num is positive, see if we can add
+  // composite registers to the existing primordial ones.
   bool from_scratch = (m_register_info.GetNumRegisters() == 0);
 
   if (!target_arch.IsValid()) {
@@ -673,8 +670,8 @@
 
   lldb::pid_t pid = m_gdb_comm.GetCurrentProcessID();
   if (pid == LLDB_INVALID_PROCESS_ID) {
-    // We don't have a valid process ID, so note that we are connected
-    // and could now request to launch or attach, or get remote process
+    // We don't have a valid process ID, so note that we are connected and
+    // could now request to launch or attach, or get remote process
     // listings...
     SetPrivateState(eStateConnected);
   } else {
@@ -725,7 +722,8 @@
 
   if (error.Success() && !GetTarget().GetArchitecture().IsValid() &&
       m_gdb_comm.GetHostArchitecture().IsValid()) {
-    // Prefer the *process'* architecture over that of the *host*, if available.
+    // Prefer the *process'* architecture over that of the *host*, if
+    // available.
     if (m_gdb_comm.GetProcessArchitecture().IsValid())
       GetTarget().SetArchitecture(m_gdb_comm.GetProcessArchitecture());
     else
@@ -804,8 +802,8 @@
 
   const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
   if (stdin_file_spec || disable_stdio) {
-    // the inferior will be reading stdin from the specified file
-    // or stdio is completely disabled
+    // the inferior will be reading stdin from the specified file or stdio
+    // is completely disabled
     m_stdin_forward = false;
   } else {
     m_stdin_forward = true;
@@ -834,10 +832,10 @@
         if (!stderr_file_spec)
           stderr_file_spec.SetFile(FileSystem::DEV_NULL, false);
       } else if (platform_sp && platform_sp->IsHost()) {
-        // If the debugserver is local and we aren't disabling STDIO, lets use
-        // a pseudo terminal to instead of relying on the 'O' packets for stdio
-        // since 'O' packets can really slow down debugging if the inferior
-        // does a lot of output.
+        // If the debugserver is local and we aren't disabling STDIO, lets
+        // use a pseudo terminal to instead of relying on the 'O' packets
+        // for stdio since 'O' packets can really slow down debugging if
+        // the inferior does a lot of output.
         if ((!stdin_file_spec || !stdout_file_spec || !stderr_file_spec) &&
             pty.OpenFirstAvailableMaster(O_RDWR | O_NOCTTY, NULL, 0)) {
           FileSpec slave_name{pty.GetSlaveName(NULL, 0), false};
@@ -1004,11 +1002,10 @@
   if (GetTarget().GetNonStopModeEnabled())
     m_gdb_comm.StartReadThread();
 
-  // We always seem to be able to open a connection to a local port
-  // so we need to make sure we can then send data to it. If we can't
-  // then we aren't actually connected to anything, so try and do the
-  // handshake with the remote GDB server and make sure that goes
-  // alright.
+  // We always seem to be able to open a connection to a local port so we
+  // need to make sure we can then send data to it. If we can't then we
+  // aren't actually connected to anything, so try and do the handshake
+  // with the remote GDB server and make sure that goes alright.
   if (!m_gdb_comm.HandshakeWithServer(&error)) {
     m_gdb_comm.Disconnect();
     if (error.Success())
@@ -1094,12 +1091,11 @@
 
         // If the remote host is ARM and we have apple as the vendor, then
         // ARM executables and shared libraries can have mixed ARM
-        // architectures.
-        // You can have an armv6 executable, and if the host is armv7, then the
-        // system will load the best possible architecture for all shared
-        // libraries
-        // it has, so we really need to take the remote host architecture as our
-        // defacto architecture in this case.
+        // architectures. You can have an armv6 executable, and if the
+        // host is armv7, then the system will load the best possible
+        // architecture for all shared libraries it has, so we really need
+        // to take the remote host architecture as our defacto
+        // architecture in this case.
 
         if ((process_arch.GetMachine() == llvm::Triple::arm ||
              process_arch.GetMachine() == llvm::Triple::thumb) &&
@@ -1151,8 +1147,8 @@
       }
     }
 
-    // Find out which StructuredDataPlugins are supported by the
-    // debug monitor.  These plugins transmit data over async $J packets.
+    // Find out which StructuredDataPlugins are supported by the debug
+    // monitor.  These plugins transmit data over async $J packets.
     auto supported_packets_array =
         m_gdb_comm.GetSupportedStructuredDataPlugins();
     if (supported_packets_array)
@@ -1361,8 +1357,8 @@
 
     if (continue_packet_error) {
       // Either no vCont support, or we tried to use part of the vCont
-      // packet that wasn't supported by the remote GDB server.
-      // We need to try and make a simple packet that can do our continue
+      // packet that wasn't supported by the remote GDB server. We need to
+      // try and make a simple packet that can do our continue
       const size_t num_continue_c_tids = m_continue_c_tids.size();
       const size_t num_continue_C_tids = m_continue_C_tids.size();
       const size_t num_continue_s_tids = m_continue_s_tids.size();
@@ -1389,11 +1385,11 @@
           const int continue_signo = m_continue_C_tids.front().second;
           // Only one thread is continuing
           if (num_continue_C_tids > 1) {
-            // More that one thread with a signal, yet we don't have
-            // vCont support and we are being asked to resume each
-            // thread with a signal, we need to make sure they are
-            // all the same signal, or we can't issue the continue
-            // accurately with the current support...
+            // More that one thread with a signal, yet we don't have vCont
+            // support and we are being asked to resume each thread with a
+            // signal, we need to make sure they are all the same signal,
+            // or we can't issue the continue accurately with the current
+            // support...
             if (num_continue_C_tids > 1) {
               continue_packet_error = false;
               for (size_t i = 1; i < m_continue_C_tids.size(); ++i) {
@@ -1566,7 +1562,8 @@
   std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
 
   if (m_jthreadsinfo_sp) {
-    // If we have the JSON threads info, we can get the thread list from that
+    // If we have the JSON threads info, we can get the thread list from
+    // that
     StructuredData::Array *thread_infos = m_jthreadsinfo_sp->GetAsArray();
     if (thread_infos && thread_infos->GetSize() > 0) {
       m_thread_ids.clear();
@@ -1586,11 +1583,11 @@
     if (!m_thread_ids.empty())
       return true;
   } else {
-    // See if we can get the thread IDs from the current stop reply packets
-    // that might contain a "threads" key/value pair
+    // See if we can get the thread IDs from the current stop reply
+    // packets that might contain a "threads" key/value pair
 
-    // Lock the thread stack while we access it
-    // Mutex::Locker stop_stack_lock(m_last_stop_packet_mutex);
+    // Lock the thread stack while we access it Mutex::Locker
+    // stop_stack_lock(m_last_stop_packet_mutex);
     std::unique_lock<std::recursive_mutex> stop_stack_lock(
         m_last_stop_packet_mutex, std::defer_lock);
     if (stop_stack_lock.try_lock()) {
@@ -1642,8 +1639,8 @@
   LLDB_LOGV(log, "pid = {0}", GetID());
 
   size_t num_thread_ids = m_thread_ids.size();
-  // The "m_thread_ids" thread ID list should always be updated after each stop
-  // reply packet, but in case it isn't, update it here.
+  // The "m_thread_ids" thread ID list should always be updated after each
+  // stop reply packet, but in case it isn't, update it here.
   if (num_thread_ids == 0) {
     if (!UpdateThreadIDList())
       return false;
@@ -1670,9 +1667,8 @@
     }
   }
 
-  // Whatever that is left in old_thread_list_copy are not
-  // present in new_thread_list. Remove non-existent threads from internal id
-  // table.
+  // Whatever that is left in old_thread_list_copy are not present in
+  // new_thread_list. Remove non-existent threads from internal id table.
   size_t old_num_thread_ids = old_thread_list_copy.GetSize(false);
   for (size_t i = 0; i < old_num_thread_ids; i++) {
     ThreadSP old_thread_sp(old_thread_list_copy.GetThreadAtIndex(i, false));
@@ -1703,8 +1699,8 @@
 
 bool ProcessGDBRemote::GetThreadStopInfoFromJSON(
     ThreadGDBRemote *thread, const StructuredData::ObjectSP &thread_infos_sp) {
-  // See if we got thread stop infos for all threads via the "jThreadsInfo"
-  // packet
+  // See if we got thread stop infos for all threads via the
+  // "jThreadsInfo" packet
   if (thread_infos_sp) {
     StructuredData::Array *thread_infos = thread_infos_sp->GetAsArray();
     if (thread_infos) {
@@ -1727,18 +1723,18 @@
 }
 
 bool ProcessGDBRemote::CalculateThreadStopInfo(ThreadGDBRemote *thread) {
-  // See if we got thread stop infos for all threads via the "jThreadsInfo"
-  // packet
+  // See if we got thread stop infos for all threads via the
+  // "jThreadsInfo" packet
   if (GetThreadStopInfoFromJSON(thread, m_jthreadsinfo_sp))
     return true;
 
-  // See if we got thread stop info for any threads valid stop info reasons
-  // threads
-  // via the "jstopinfo" packet stop reply packet key/value pair?
+  // See if we got thread stop info for any threads valid stop info
+  // reasons threads via the "jstopinfo" packet stop reply packet
+  // key/value pair?
   if (m_jstopinfo_sp) {
-    // If we have "jstopinfo" then we have stop descriptions for all threads
-    // that have stop reasons, and if there is no entry for a thread, then
-    // it has no stop reason.
+    // If we have "jstopinfo" then we have stop descriptions for all
+    // threads that have stop reasons, and if there is no entry for a
+    // thread, then it has no stop reason.
     thread->GetRegisterContext()->InvalidateIfNeeded(true);
     if (!GetThreadStopInfoFromJSON(thread, m_jstopinfo_sp)) {
       thread->SetStopInfo(StopInfoSP());
@@ -1766,10 +1762,10 @@
   if (tid != LLDB_INVALID_THREAD_ID) {
     // Scope for "locker" below
     {
-      // m_thread_list_real does have its own mutex, but we need to
-      // hold onto the mutex between the call to
-      // m_thread_list_real.FindThreadByID(...)
-      // and the m_thread_list_real.AddThread(...) so it doesn't change on us
+      // m_thread_list_real does have its own mutex, but we need to hold
+      // onto the mutex between the call to
+      // m_thread_list_real.FindThreadByID(...) and the
+      // m_thread_list_real.AddThread(...) so it doesn't change on us
       std::lock_guard<std::recursive_mutex> guard(
           m_thread_list_real.GetMutex());
       thread_sp = m_thread_list_real.FindThreadByProtocolID(tid, false);
@@ -1803,8 +1799,8 @@
       thread_sp->SetName(thread_name.empty() ? NULL : thread_name.c_str());
 
       gdb_thread->SetThreadDispatchQAddr(thread_dispatch_qaddr);
-      // Check if the GDB server was able to provide the queue name, kind and
-      // serial number
+      // Check if the GDB server was able to provide the queue name, kind
+      // and serial number
       if (queue_vars_valid)
         gdb_thread->SetQueueInfo(std::move(queue_name), queue_kind,
                                  queue_serial, dispatch_queue_t,
@@ -1821,8 +1817,8 @@
       // Make sure we update our thread stop reason just once
       if (!thread_sp->StopInfoIsUpToDate()) {
         thread_sp->SetStopInfo(StopInfoSP());
-        // If there's a memory thread backed by this thread, we need to use it
-        // to calculate StopInfo.
+        // If there's a memory thread backed by this thread, we need to
+        // use it to calculate StopInfo.
         if (ThreadSP memory_thread_sp =
                 m_thread_list.GetBackingThread(thread_sp))
           thread_sp = memory_thread_sp;
@@ -1846,9 +1842,9 @@
                                                       ->GetBreakpointSiteList()
                                                       .FindByAddress(pc);
 
-              // If the current pc is a breakpoint site then the StopInfo should
-              // be set to Breakpoint
-              // Otherwise, it will be set to Trace.
+              // If the current pc is a breakpoint site then the StopInfo
+              // should be set to Breakpoint Otherwise, it will be set to
+              // Trace.
               if (bp_site_sp &&
                   bp_site_sp->ValidForThisThread(thread_sp.get())) {
                 thread_sp->SetStopInfo(
@@ -1864,12 +1860,12 @@
                                                       ->GetBreakpointSiteList()
                                                       .FindByAddress(pc);
               if (bp_site_sp) {
-                // If the breakpoint is for this thread, then we'll report the
-                // hit, but if it is for another thread,
-                // we can just report no reason.  We don't need to worry about
-                // stepping over the breakpoint here, that
-                // will be taken care of when the thread resumes and notices
-                // that there's a breakpoint under the pc.
+                // If the breakpoint is for this thread, then we'll report
+                // the hit, but if it is for another thread, we can just
+                // report no reason.  We don't need to worry about
+                // stepping over the breakpoint here, that will be taken
+                // care of when the thread resumes and notices that
+                // there's a breakpoint under the pc.
                 handled = true;
                 if (bp_site_sp->ValidForThisThread(thread_sp.get())) {
                   thread_sp->SetStopInfo(
@@ -1881,7 +1877,8 @@
                 }
               }
             } else if (reason.compare("trap") == 0) {
-              // Let the trap just use the standard signal stop reason below...
+              // Let the trap just use the standard signal stop reason
+              // below...
             } else if (reason.compare("watchpoint") == 0) {
               StringExtractor desc_extractor(description.c_str());
               addr_t wp_addr = desc_extractor.GetU64(LLDB_INVALID_ADDRESS);
@@ -1930,12 +1927,10 @@
                 thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(
                     pc);
 
-            // If the current pc is a breakpoint site then the StopInfo should
-            // be set to Breakpoint
-            // even though the remote stub did not set it as such. This can
-            // happen when
-            // the thread is involuntarily interrupted (e.g. due to stops on
-            // other
+            // If the current pc is a breakpoint site then the StopInfo
+            // should be set to Breakpoint even though the remote stub did
+            // not set it as such. This can happen when the thread is
+            // involuntarily interrupted (e.g. due to stops on other
             // threads) just as it is about to execute the breakpoint
             // instruction.
             if (bp_site_sp && bp_site_sp->ValidForThisThread(thread_sp.get())) {
@@ -1948,8 +1943,8 @@
 
           if (!handled && signo && did_exec == false) {
             if (signo == SIGTRAP) {
-              // Currently we are going to assume SIGTRAP means we are either
-              // hitting a breakpoint or hardware single stepping.
+              // Currently we are going to assume SIGTRAP means we are
+              // either hitting a breakpoint or hardware single stepping.
               handled = true;
               addr_t pc = thread_sp->GetRegisterContext()->GetPC() +
                           m_breakpoint_pc_offset;
@@ -1958,12 +1953,12 @@
                                                       .FindByAddress(pc);
 
               if (bp_site_sp) {
-                // If the breakpoint is for this thread, then we'll report the
-                // hit, but if it is for another thread,
-                // we can just report no reason.  We don't need to worry about
-                // stepping over the breakpoint here, that
-                // will be taken care of when the thread resumes and notices
-                // that there's a breakpoint under the pc.
+                // If the breakpoint is for this thread, then we'll report
+                // the hit, but if it is for another thread, we can just
+                // report no reason.  We don't need to worry about
+                // stepping over the breakpoint here, that will be taken
+                // care of when the thread resumes and notices that
+                // there's a breakpoint under the pc.
                 if (bp_site_sp->ValidForThisThread(thread_sp.get())) {
                   if (m_breakpoint_pc_offset != 0)
                     thread_sp->GetRegisterContext()->SetPC(pc);
@@ -1975,11 +1970,10 @@
                   thread_sp->SetStopInfo(invalid_stop_info_sp);
                 }
               } else {
-                // If we were stepping then assume the stop was the result of
-                // the trace.  If we were
-                // not stepping then report the SIGTRAP.
-                // FIXME: We are still missing the case where we single step
-                // over a trap instruction.
+                // If we were stepping then assume the stop was the result
+                // of the trace.  If we were not stepping then report the
+                // SIGTRAP. FIXME: We are still missing the case where we
+                // single step over a trap instruction.
                 if (thread_sp->GetTemporaryResumeState() == eStateStepping)
                   thread_sp->SetStopInfo(
                       StopInfo::CreateStopReasonToTrace(*thread_sp));
@@ -2174,9 +2168,9 @@
   case 'S': {
     // This is a bit of a hack, but is is required. If we did exec, we
     // need to clear our thread lists and also know to rebuild our dynamic
-    // register info before we lookup and threads and populate the expedited
-    // register values so we need to know this right away so we can cleanup
-    // and update our registers.
+    // register info before we lookup and threads and populate the
+    // expedited register values so we need to know this right away so we
+    // can cleanup and update our registers.
     const uint32_t stop_id = GetStopID();
     if (stop_id == 0) {
       // Our first stop, make sure we have a process ID, and also make
@@ -2225,9 +2219,8 @@
             m_thread_list_real.GetMutex());
 
         m_thread_ids.clear();
-        // A comma separated list of all threads in the current
-        // process that includes the thread for this stop reply
-        // packet
+        // A comma separated list of all threads in the current process
+        // that includes the thread for this stop reply packet
         lldb::tid_t tid;
         while (!value.empty()) {
           llvm::StringRef tid_str;
@@ -2238,9 +2231,8 @@
         }
       } else if (key.compare("thread-pcs") == 0) {
         m_thread_pcs.clear();
-        // A comma separated list of all threads in the current
-        // process that includes the thread for this stop reply
-        // packet
+        // A comma separated list of all threads in the current process
+        // that includes the thread for this stop reply packet
         lldb::addr_t pc;
         while (!value.empty()) {
           llvm::StringRef pc_str;
@@ -2255,8 +2247,9 @@
         // Now convert the HEX bytes into a string value
         json_extractor.GetHexByteString(json);
 
-        // This JSON contains thread IDs and thread stop info for all threads.
-        // It doesn't contain expedited registers, memory or queue info.
+        // This JSON contains thread IDs and thread stop info for all
+        // threads. It doesn't contain expedited registers, memory or
+        // queue info.
         m_jstopinfo_sp = StructuredData::ParseJSON(json);
       } else if (key.compare("hexname") == 0) {
         StringExtractor name_extractor(value);
@@ -2292,16 +2285,14 @@
         desc_extractor.GetHexByteString(description);
       } else if (key.compare("memory") == 0) {
         // Expedited memory. GDB servers can choose to send back expedited
-        // memory
-        // that can populate the L1 memory cache in the process so that things
-        // like
-        // the frame pointer backchain can be expedited. This will help stack
-        // backtracing be more efficient by not having to send as many memory
-        // read
-        // requests down the remote GDB server.
-
-        // Key/value pair format: memory:<addr>=<bytes>;
-        // <addr> is a number whose base will be interpreted by the prefix:
+        // memory that can populate the L1 memory cache in the process so
+        // that things like the frame pointer backchain can be expedited.
+        // This will help stack backtracing be more efficient by not
+        // having to send as many memory read requests down the remote GDB
+        // server.
+
+        // Key/value pair format: memory:<addr>=<bytes>; <addr> is a
+        // number whose base will be interpreted by the prefix:
         //      "0x[0-9a-fA-F]+" for hex
         //      "0[0-7]+" for octal
         //      "[1-9]+" for decimal
@@ -2348,9 +2339,9 @@
     }
 
     if (tid == LLDB_INVALID_THREAD_ID) {
-      // A thread id may be invalid if the response is old style 'S' packet
-      // which does not provide the
-      // thread information. So update the thread list and choose the first one.
+      // A thread id may be invalid if the response is old style 'S'
+      // packet which does not provide the thread information. So update
+      // the thread list and choose the first one.
       UpdateThreadIDList();
 
       if (!m_thread_ids.empty()) {
@@ -2383,9 +2374,9 @@
 
   m_thread_ids.clear();
   m_thread_pcs.clear();
-  // Set the thread stop info. It might have a "threads" key whose value is
-  // a list of all thread IDs in the current process, so m_thread_ids might
-  // get set.
+  // Set the thread stop info. It might have a "threads" key whose value
+  // is a list of all thread IDs in the current process, so m_thread_ids
+  // might get set.
 
   // Scope for the lock
   {
@@ -2416,8 +2407,8 @@
     m_initial_tid = LLDB_INVALID_THREAD_ID;
   }
 
-  // Let all threads recover from stopping and do any clean up based
-  // on the previous thread state (if any).
+  // Let all threads recover from stopping and do any clean up based on
+  // the previous thread state (if any).
   m_thread_list_real.RefreshStateAfterStop();
 }
 
@@ -2468,32 +2459,26 @@
   if (log)
     log->Printf("ProcessGDBRemote::DoDestroy()");
 
-  // There is a bug in older iOS debugservers where they don't shut down the
-  // process
-  // they are debugging properly.  If the process is sitting at a breakpoint or
-  // an exception,
-  // this can cause problems with restarting.  So we check to see if any of our
-  // threads are stopped
-  // at a breakpoint, and if so we remove all the breakpoints, resume the
-  // process, and THEN
-  // destroy it again.
+  // There is a bug in older iOS debugservers where they don't shut down
+  // the process they are debugging properly.  If the process is sitting
+  // at a breakpoint or an exception, this can cause problems with
+  // restarting.  So we check to see if any of our threads are stopped at
+  // a breakpoint, and if so we remove all the breakpoints, resume the
+  // process, and THEN destroy it again.
   //
-  // Note, we don't have a good way to test the version of debugserver, but I
-  // happen to know that
-  // the set of all the iOS debugservers which don't support
-  // GetThreadSuffixSupported() and that of
-  // the debugservers with this bug are equal.  There really should be a better
-  // way to test this!
+  // Note, we don't have a good way to test the version of debugserver,
+  // but I happen to know that the set of all the iOS debugservers which
+  // don't support GetThreadSuffixSupported() and that of the debugservers
+  // with this bug are equal.  There really should be a better way to test
+  // this!
   //
-  // We also use m_destroy_tried_resuming to make sure we only do this once, if
-  // we resume and then halt and
-  // get called here to destroy again and we're still at a breakpoint or
-  // exception, then we should
-  // just do the straight-forward kill.
+  // We also use m_destroy_tried_resuming to make sure we only do this
+  // once, if we resume and then halt and get called here to destroy again
+  // and we're still at a breakpoint or exception, then we should just do
+  // the straight-forward kill.
   //
-  // And of course, if we weren't able to stop the process by the time we get
-  // here, it isn't
-  // necessary (or helpful) to do any of this.
+  // And of course, if we weren't able to stop the process by the time we
+  // get here, it isn't necessary (or helpful) to do any of this.
 
   if (!m_gdb_comm.GetThreadSuffixSupported() &&
       m_public_state.GetValue() != eStateRunning) {
@@ -2507,10 +2492,9 @@
           log->PutCString("ProcessGDBRemote::DoDestroy() - Tried resuming to "
                           "destroy once already, not doing it again.");
       } else {
-        // At present, the plans are discarded and the breakpoints disabled
-        // Process::Destroy,
-        // but we really need it to happen here and it doesn't matter if we do
-        // it twice.
+        // At present, the plans are discarded and the breakpoints
+        // disabled Process::Destroy, but we really need it to happen here
+        // and it doesn't matter if we do it twice.
         m_thread_list.DiscardThreadPlans();
         DisableAllBreakpointSites();
 
@@ -2546,13 +2530,12 @@
                             "breakpoint, continue and then kill.");
           m_destroy_tried_resuming = true;
 
-          // If we are going to run again before killing, it would be good to
-          // suspend all the threads
-          // before resuming so they won't get into more trouble.  Sadly, for
-          // the threads stopped with
-          // the breakpoint or exception, the exception doesn't get cleared if
-          // it is suspended, so we do
-          // have to run the risk of letting those threads proceed a bit.
+          // If we are going to run again before killing, it would be good
+          // to suspend all the threads before resuming so they won't get
+          // into more trouble.  Sadly, for the threads stopped with the
+          // breakpoint or exception, the exception doesn't get cleared if
+          // it is suspended, so we do have to run the risk of letting
+          // those threads proceed a bit.
 
           {
             std::lock_guard<std::recursive_mutex> guard(threads.GetMutex());
@@ -2599,18 +2582,16 @@
         if (packet_cmd == 'W' || packet_cmd == 'X') {
 #if defined(__APPLE__)
           // For Native processes on Mac OS X, we launch through the Host
-          // Platform, then hand the process off
-          // to debugserver, which becomes the parent process through
-          // "PT_ATTACH".  Then when we go to kill
-          // the process on Mac OS X we call ptrace(PT_KILL) to kill it, then we
-          // call waitpid which returns
-          // with no error and the correct status.  But amusingly enough that
-          // doesn't seem to actually reap
-          // the process, but instead it is left around as a Zombie.  Probably
-          // the kernel is in the process of
-          // switching ownership back to lldb which was the original parent, and
-          // gets confused in the handoff.
-          // Anyway, so call waitpid here to finally reap it.
+          // Platform, then hand the process off to debugserver, which
+          // becomes the parent process through "PT_ATTACH".  Then when we
+          // go to kill the process on Mac OS X we call ptrace(PT_KILL) to
+          // kill it, then we call waitpid which returns with no error and
+          // the correct status.  But amusingly enough that doesn't seem
+          // to actually reap the process, but instead it is left around
+          // as a Zombie.  Probably the kernel is in the process of
+          // switching ownership back to lldb which was the original
+          // parent, and gets confused in the handoff. Anyway, so call
+          // waitpid here to finally reap it.
           PlatformSP platform_sp(GetTarget().GetPlatform());
           if (platform_sp && platform_sp->IsHost()) {
             int status;
@@ -2643,9 +2624,9 @@
       exit_string.assign("killed or interrupted while attaching.");
     }
   } else {
-    // If we missed setting the exit status on the way out, do it here.
-    // NB set exit status can be called multiple times, the first one sets the
-    // status.
+    // If we missed setting the exit status on the way out, do it here. NB
+    // set exit status can be called multiple times, the first one sets
+    // the status.
     exit_string.assign("destroying when not connected to debugserver");
   }
 
@@ -2681,9 +2662,8 @@
     if (GetTarget().GetNonStopModeEnabled() == false)
       m_stop_packet_stack.clear();
 
-    // Add this stop packet to the stop packet stack
-    // This stack will get popped and examined when we switch to the
-    // Stopped state
+    // Add this stop packet to the stop packet stack This stack will get
+    // popped and examined when we switch to the Stopped state
     m_stop_packet_stack.push_back(response);
   }
 }
@@ -2715,17 +2695,17 @@
 }
 
 void ProcessGDBRemote::WillPublicStop() {
-  // See if the GDB remote client supports the JSON threads info.
-  // If so, we gather stop info for all threads, expedited registers,
-  // expedited memory, runtime queue information (iOS and MacOSX only),
-  // and more. Expediting memory will help stack backtracing be much
-  // faster. Expediting registers will make sure we don't have to read
-  // the thread registers for GPRs.
+  // See if the GDB remote client supports the JSON threads info. If so,
+  // we gather stop info for all threads, expedited registers, expedited
+  // memory, runtime queue information (iOS and MacOSX only), and more.
+  // Expediting memory will help stack backtracing be much faster.
+  // Expediting registers will make sure we don't have to read the thread
+  // registers for GPRs.
   m_jthreadsinfo_sp = m_gdb_comm.GetThreadsInfo();
 
   if (m_jthreadsinfo_sp) {
-    // Now set the stop info for each thread and also expedite any registers
-    // and memory that was in the jThreadsInfo response.
+    // Now set the stop info for each thread and also expedite any
+    // registers and memory that was in the jThreadsInfo response.
     StructuredData::Array *thread_infos = m_jthreadsinfo_sp->GetAsArray();
     if (thread_infos) {
       const size_t n = thread_infos->GetSize();
@@ -2770,14 +2750,13 @@
       error.Clear();
       if (binary_memory_read) {
         // The lower level GDBRemoteCommunication packet receive layer has
-        // already de-quoted any
-        // 0x7d character escaping that was present in the packet
+        // already de-quoted any 0x7d character escaping that was present
+        // in the packet
 
         size_t data_received_size = response.GetBytesLeft();
         if (data_received_size > size) {
-          // Don't write past the end of BUF if the remote debug server gave us
-          // too
-          // much data for some reason.
+          // Don't write past the end of BUF if the remote debug server
+          // gave us too much data for some reason.
           data_received_size = size;
         }
         memcpy(buf, response.GetStringRef().data(), data_received_size);
@@ -2817,9 +2796,9 @@
     error = FlashDone();
   else
     // Even though some of the writing failed, try to send a flash done if
-    // some of the writing succeeded so the flash state is reset to normal,
-    // but don't stomp on the error status that was set in the write failure
-    // since that's the one we want to report back.
+    // some of the writing succeeded so the flash state is reset to
+    // normal, but don't stomp on the error status that was set in the
+    // write failure since that's the one we want to report back.
     FlashDone();
   m_allow_flash_writes = false;
   return error;
@@ -2841,10 +2820,11 @@
   if (!status.Success())
     return status;
 
-  // The gdb spec doesn't say if erasures are allowed across multiple regions,
-  // but we'll disallow it to be safe and to keep the logic simple by worring
-  // about only one region's block size.  DoMemoryWrite is this function's
-  // primary user, and it can easily keep writes within a single memory region
+  // The gdb spec doesn't say if erasures are allowed across multiple
+  // regions, but we'll disallow it to be safe and to keep the logic
+  // simple by worring about only one region's block size.  DoMemoryWrite
+  // is this function's primary user, and it can easily keep writes within
+  // a single memory region
   if (addr + size > region.GetRange().GetRangeEnd()) {
     status.SetErrorString("Unable to erase flash in multiple regions");
     return status;
@@ -2856,8 +2836,8 @@
     return status;
   }
 
-  // Erasures can only be done on block boundary adresses, so round down addr
-  // and round up size
+  // Erasures can only be done on block boundary adresses, so round down
+  // addr and round up size
   lldb::addr_t block_start_addr = addr - (addr % blocksize);
   size += (addr - block_start_addr);
   if ((size % blocksize) != 0)
@@ -2868,18 +2848,20 @@
   if (HasErased(range))
     return status;
 
-  // We haven't erased the entire range, but we may have erased part of it.
-  // (e.g., block A is already erased and range starts in A and ends in B).
-  // So, adjust range if necessary to exclude already erased blocks.
+  // We haven't erased the entire range, but we may have erased part of
+  // it. (e.g., block A is already erased and range starts in A and ends
+  // in B). So, adjust range if necessary to exclude already erased
+  // blocks.
   if (!m_erased_flash_ranges.IsEmpty()) {
-    // Assuming that writes and erasures are done in increasing addr order,
-    // because that is a requirement of the vFlashWrite command.  Therefore,
-    // we only need to look at the last range in the list for overlap.
+    // Assuming that writes and erasures are done in increasing addr
+    // order, because that is a requirement of the vFlashWrite command.
+    // Therefore, we only need to look at the last range in the list for
+    // overlap.
     const auto &last_range = *m_erased_flash_ranges.Back();
     if (range.GetRangeBase() < last_range.GetRangeEnd()) {
       auto overlap = last_range.GetRangeEnd() - range.GetRangeBase();
-      // overlap will be less than range.GetByteSize() or else HasErased() would
-      // have been true
+      // overlap will be less than range.GetByteSize() or else HasErased()
+      // would have been true
       range.SetByteSize(range.GetByteSize() - overlap);
       range.SetRangeBase(range.GetRangeBase() + overlap);
     }
@@ -2915,8 +2897,9 @@
 
 Status ProcessGDBRemote::FlashDone() {
   Status status;
-  // If we haven't erased any blocks, then we must not have written anything
-  // either, so there is no need to actually send a vFlashDone command
+  // If we haven't erased any blocks, then we must not have written
+  // anything either, so there is no need to actually send a vFlashDone
+  // command
   if (m_erased_flash_ranges.IsEmpty())
     return status;
   StringExtractorGDBRemote response;
@@ -3146,19 +3129,15 @@
   // Get the software breakpoint trap opcode size
   const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode(bp_site);
 
-  // SupportsGDBStoppointPacket() simply checks a boolean, indicating if this
-  // breakpoint type
-  // is supported by the remote stub. These are set to true by default, and
-  // later set to false
-  // only after we receive an unimplemented response when sending a breakpoint
-  // packet. This means
-  // initially that unless we were specifically instructed to use a hardware
-  // breakpoint, LLDB will
-  // attempt to set a software breakpoint. HardwareRequired() also queries a
-  // boolean variable which
-  // indicates if the user specifically asked for hardware breakpoints.  If true
-  // then we will
-  // skip over software breakpoints.
+  // SupportsGDBStoppointPacket() simply checks a boolean, indicating if
+  // this breakpoint type is supported by the remote stub. These are set
+  // to true by default, and later set to false only after we receive an
+  // unimplemented response when sending a breakpoint packet. This means
+  // initially that unless we were specifically instructed to use a
+  // hardware breakpoint, LLDB will attempt to set a software breakpoint.
+  // HardwareRequired() also queries a boolean variable which indicates if
+  // the user specifically asked for hardware breakpoints.  If true then
+  // we will skip over software breakpoints.
   if (m_gdb_comm.SupportsGDBStoppointPacket(eBreakpointSoftware) &&
       (!bp_site->HardwareRequired())) {
     // Try to send off a software breakpoint packet ($Z0)
@@ -3171,19 +3150,15 @@
       return error;
     }
 
-    // SendGDBStoppointTypePacket() will return an error if it was unable to set
-    // this
-    // breakpoint. We need to differentiate between a error specific to placing
-    // this breakpoint
-    // or if we have learned that this breakpoint type is unsupported. To do
-    // this, we
-    // must test the support boolean for this breakpoint type to see if it now
-    // indicates that
-    // this breakpoint type is unsupported.  If they are still supported then we
-    // should return
-    // with the error code.  If they are now unsupported, then we would like to
-    // fall through
-    // and try another form of breakpoint.
+    // SendGDBStoppointTypePacket() will return an error if it was unable
+    // to set this breakpoint. We need to differentiate between a error
+    // specific to placing this breakpoint or if we have learned that this
+    // breakpoint type is unsupported. To do this, we must test the
+    // support boolean for this breakpoint type to see if it now indicates
+    // that this breakpoint type is unsupported.  If they are still
+    // supported then we should return with the error code.  If they are
+    // now unsupported, then we would like to fall through and try another
+    // form of breakpoint.
     if (m_gdb_comm.SupportsGDBStoppointPacket(eBreakpointSoftware)) {
       if (error_no != UINT8_MAX)
         error.SetErrorStringWithFormat(
@@ -3194,21 +3169,19 @@
     }
 
     // We reach here when software breakpoints have been found to be
-    // unsupported. For future
-    // calls to set a breakpoint, we will not attempt to set a breakpoint with a
-    // type that is
-    // known not to be supported.
+    // unsupported. For future calls to set a breakpoint, we will not
+    // attempt to set a breakpoint with a type that is known not to be
+    // supported.
     if (log)
       log->Printf("Software breakpoints are unsupported");
 
     // So we will fall through and try a hardware breakpoint
   }
 
-  // The process of setting a hardware breakpoint is much the same as above.  We
-  // check the
-  // supported boolean for this breakpoint type, and if it is thought to be
-  // supported then we
-  // will try to set this breakpoint with a hardware breakpoint.
+  // The process of setting a hardware breakpoint is much the same as
+  // above.  We check the supported boolean for this breakpoint type, and
+  // if it is thought to be supported then we will try to set this
+  // breakpoint with a hardware breakpoint.
   if (m_gdb_comm.SupportsGDBStoppointPacket(eBreakpointHardware)) {
     // Try to send off a hardware breakpoint packet ($Z1)
     uint8_t error_no = m_gdb_comm.SendGDBStoppointTypePacket(
@@ -3220,8 +3193,8 @@
       return error;
     }
 
-    // Check if the error was something other then an unsupported breakpoint
-    // type
+    // Check if the error was something other then an unsupported
+    // breakpoint type
     if (m_gdb_comm.SupportsGDBStoppointPacket(eBreakpointHardware)) {
       // Unable to set this hardware breakpoint
       if (error_no != UINT8_MAX)
@@ -3244,7 +3217,8 @@
     // Finally we will falling through to a #trap style breakpoint
   }
 
-  // Don't fall through when hardware breakpoints were specifically requested
+  // Don't fall through when hardware breakpoints were specifically
+  // requested
   if (bp_site->HardwareRequired()) {
     error.SetErrorString("hardware breakpoints are not supported");
     return error;
@@ -3381,10 +3355,10 @@
         log->Printf("ProcessGDBRemote::DisableWatchpoint (watchID = %" PRIu64
                     ") addr = 0x%8.8" PRIx64 " -- SUCCESS (already disabled)",
                     watchID, (uint64_t)addr);
-      // See also 'class WatchpointSentry' within StopInfo.cpp.
-      // This disabling attempt might come from the user-supplied actions, we'll
-      // route it in order for
-      // the watchpoint object to intelligently process this action.
+      // See also 'class WatchpointSentry' within StopInfo.cpp. This
+      // disabling attempt might come from the user-supplied actions,
+      // we'll route it in order for the watchpoint object to
+      // intelligently process this action.
       wp->SetEnabled(false, notify);
       return error;
     }
@@ -3481,8 +3455,8 @@
 
     int communication_fd = -1;
 #ifdef USE_SOCKETPAIR_FOR_LOCAL_CONNECTION
-    // Use a socketpair on non-Windows systems for security and performance
-    // reasons.
+    // Use a socketpair on non-Windows systems for security and
+    // performance reasons.
     int sockets[2]; /* the pair of socket descriptors */
     if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockets) == -1) {
       error.SetErrorToErrno();
@@ -3510,8 +3484,8 @@
 
     if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID) {
 #ifdef USE_SOCKETPAIR_FOR_LOCAL_CONNECTION
-      // Our process spawned correctly, we can now set our connection to use our
-      // end of the socket pair
+      // Our process spawned correctly, we can now set our connection to
+      // use our end of the socket pair
       cleanup_our.disable();
       m_gdb_comm.SetConnection(new ConnectionFileDescriptor(our_socket, true));
 #endif
@@ -3528,8 +3502,8 @@
     }
 
     if (m_gdb_comm.IsConnected()) {
-      // Finish the connection process by doing the handshake without connecting
-      // (send NULL URL)
+      // Finish the connection process by doing the handshake without
+      // connecting (send NULL URL)
       ConnectToDebugserver("");
     } else {
       error.SetErrorString("connection failed");
@@ -3561,12 +3535,12 @@
   if (!process_sp || process_sp->m_debugserver_pid != debugserver_pid)
     return handled;
 
-  // Sleep for a half a second to make sure our inferior process has
-  // time to set its exit status before we set it incorrectly when
-  // both the debugserver and the inferior process shut down.
+  // Sleep for a half a second to make sure our inferior process has time
+  // to set its exit status before we set it incorrectly when both the
+  // debugserver and the inferior process shut down.
   usleep(500000);
-  // If our process hasn't yet exited, debugserver might have died.
-  // If the process did exit, then we are reaping it.
+  // If our process hasn't yet exited, debugserver might have died. If the
+  // process did exit, then we are reaping it.
   const StateType state = process_sp->GetState();
 
   if (state != eStateInvalid && state != eStateUnloaded &&
@@ -3589,8 +3563,8 @@
 
     process_sp->SetExitStatus(-1, error_str);
   }
-  // Debugserver has exited we need to let our ProcessGDBRemote
-  // know that it no longer has a debugserver instance
+  // Debugserver has exited we need to let our ProcessGDBRemote know that
+  // it no longer has a debugserver instance
   process_sp->m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
   return handled;
 }
@@ -3680,10 +3654,9 @@
   // check for more stop reasons
   HandleStopReplySequence();
 
-  // if the process is stopped then we need to fake a resume
-  // so that we can stop properly with the new break. This
-  // is possible due to SetPrivateState() broadcasting the
-  // state change as a side effect.
+  // if the process is stopped then we need to fake a resume so that we
+  // can stop properly with the new break. This is possible due to
+  // SetPrivateState() broadcasting the state change as a side effect.
   if (GetPrivateState() == lldb::StateType::eStateStopped) {
     SetPrivateState(lldb::StateType::eStateRunning);
   }
@@ -3755,13 +3728,12 @@
                       llvm::StringRef(continue_cstr, continue_cstr_len),
                       response);
 
-              // We need to immediately clear the thread ID list so we are sure
-              // to get a valid list of threads.
-              // The thread ID list might be contained within the "response", or
-              // the stop reply packet that
-              // caused the stop. So clear it now before we give the stop reply
-              // packet to the process
-              // using the process->SetLastStopPacket()...
+              // We need to immediately clear the thread ID list so we are
+              // sure to get a valid list of threads. The thread ID list
+              // might be contained within the "response", or the stop
+              // reply packet that caused the stop. So clear it now before
+              // we give the stop reply packet to the process using the
+              // process->SetLastStopPacket()...
               process->ClearThreadIDList();
 
               switch (stop_state) {
@@ -3795,11 +3767,11 @@
                 break;
               }
               case eStateInvalid: {
-                // Check to see if we were trying to attach and if we got back
-                // the "E87" error code from debugserver -- this indicates that
-                // the process is not debuggable.  Return a slightly more
-                // helpful
-                // error message about why the attach failed.
+                // Check to see if we were trying to attach and if we got
+                // back the "E87" error code from debugserver -- this
+                // indicates that the process is not debuggable.  Return a
+                // slightly more helpful error message about why the
+                // attach failed.
                 if (::strstr(continue_cstr, "vAttach") != NULL &&
                     response.GetError() == 0x87) {
                   process->SetExitStatus(-1, "cannot attach to process due to "
@@ -3883,8 +3855,8 @@
 }
 
 // uint32_t
-// ProcessGDBRemote::ListProcessesMatchingName (const char *name, StringList
-// &matches, std::vector<lldb::pid_t> &pids)
+// ProcessGDBRemote::ListProcessesMatchingName (const char *name,
+// StringList &matches, std::vector<lldb::pid_t> &pids)
 //{
 //    // If we are planning to launch the debugserver remotely, then we need to
 //    fire up a debugserver
@@ -3905,9 +3877,9 @@
 bool ProcessGDBRemote::NewThreadNotifyBreakpointHit(
     void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id,
     lldb::user_id_t break_loc_id) {
-  // I don't think I have to do anything here, just make sure I notice the new
-  // thread when it starts to
-  // run so I can stop it if that's what I want to do.
+  // I don't think I have to do anything here, just make sure I notice the
+  // new thread when it starts to run so I can stop it if that's what I
+  // want to do.
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
   if (log)
     log->Printf("Hit New Thread Notification breakpoint.");
@@ -3918,8 +3890,8 @@
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
   LLDB_LOG(log, "Check if need to update ignored signals");
 
-  // QPassSignals package is not supported by the server,
-  // there is no way we can ignore any signals on server side.
+  // QPassSignals package is not supported by the server, there is no way
+  // we can ignore any signals on server side.
   if (!m_gdb_comm.GetQPassSignalsSupported())
     return Status();
 
@@ -4043,9 +4015,9 @@
 
     // FIXME the final character of a JSON dictionary, '}', is the escape
     // character in gdb-remote binary mode.  lldb currently doesn't escape
-    // these characters in its packet output -- so we add the quoted version
-    // of the } character here manually in case we talk to a debugserver which
-    // un-escapes the characters at packet read time.
+    // these characters in its packet output -- so we add the quoted
+    // version of the } character here manually in case we talk to a
+    // debugserver which un-escapes the characters at packet read time.
     packet << (char)(0x7d ^ 0x20);
 
     StringExtractorGDBRemote response;
@@ -4115,9 +4087,9 @@
 
     // FIXME the final character of a JSON dictionary, '}', is the escape
     // character in gdb-remote binary mode.  lldb currently doesn't escape
-    // these characters in its packet output -- so we add the quoted version
-    // of the } character here manually in case we talk to a debugserver which
-    // un-escapes the characters at packet read time.
+    // these characters in its packet output -- so we add the quoted
+    // version of the } character here manually in case we talk to a
+    // debugserver which un-escapes the characters at packet read time.
     packet << (char)(0x7d ^ 0x20);
 
     StringExtractorGDBRemote response;
@@ -4148,9 +4120,9 @@
 
     // FIXME the final character of a JSON dictionary, '}', is the escape
     // character in gdb-remote binary mode.  lldb currently doesn't escape
-    // these characters in its packet output -- so we add the quoted version
-    // of the } character here manually in case we talk to a debugserver which
-    // un-escapes the characters at packet read time.
+    // these characters in its packet output -- so we add the quoted
+    // version of the } character here manually in case we talk to a
+    // debugserver which un-escapes the characters at packet read time.
     packet << (char)(0x7d ^ 0x20);
 
     StringExtractorGDBRemote response;
@@ -4175,11 +4147,11 @@
   return m_gdb_comm.ConfigureRemoteStructuredData(type_name, config_sp);
 }
 
-// Establish the largest memory read/write payloads we should use.
-// If the remote stub has a max packet size, stay under that size.
+// Establish the largest memory read/write payloads we should use. If the
+// remote stub has a max packet size, stay under that size.
 //
-// If the remote stub's max packet size is crazy large, use a
-// reasonable largeish default.
+// If the remote stub's max packet size is crazy large, use a reasonable
+// largeish default.
 //
 // If the remote stub doesn't advertise a max packet size, use a
 // conservative default.
@@ -4194,8 +4166,8 @@
       // Save the stub's claimed maximum packet size
       m_remote_stub_max_memory_size = stub_max_size;
 
-      // Even if the stub says it can support ginormous packets,
-      // don't exceed our reasonable largeish default packet size.
+      // Even if the stub says it can support ginormous packets, don't
+      // exceed our reasonable largeish default packet size.
       if (stub_max_size > reasonable_largeish_default) {
         stub_max_size = reasonable_largeish_default;
       }
@@ -4206,8 +4178,8 @@
       if (stub_max_size > 70)
         stub_max_size -= 32 + 32 + 6;
       else {
-        // In unlikely scenario that max packet size is less then 70, we will
-        // hope that data being written is small enough to fit.
+        // In unlikely scenario that max packet size is less then 70, we
+        // will hope that data being written is small enough to fit.
         Log *log(ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(
             GDBR_LOG_COMM | GDBR_LOG_MEMORY));
         if (log)
@@ -4460,8 +4432,8 @@
         }
 
         // Only update the register set name if we didn't get a "reg_set"
-        // attribute.
-        // "set_name" will be empty if we didn't have a "reg_set" attribute.
+        // attribute. "set_name" will be empty if we didn't have a
+        // "reg_set" attribute.
         if (!set_name && !gdb_group.empty())
           set_name.SetCString(gdb_group.c_str());
 
@@ -4488,8 +4460,8 @@
 
 } // namespace {}
 
-// query the target of gdb-remote for extended target information
-// return:  'true'  on success
+// query the target of gdb-remote for extended target information return:
+// 'true'  on success
 //          'false' on failure
 bool ProcessGDBRemote::GetGDBServerRegisterInfo(ArchSpec &arch_to_use) {
   // Make sure LLDB has an XML parser it can use first
@@ -4571,15 +4543,14 @@
         }
       }
 
-      // Initialize these outside of ParseRegisters, since they should not be
-      // reset inside each include feature
+      // Initialize these outside of ParseRegisters, since they should not
+      // be reset inside each include feature
       uint32_t cur_reg_num = 0;
       uint32_t reg_offset = 0;
 
-      // Don't use Process::GetABI, this code gets called from DidAttach, and in
-      // that context we haven't
-      // set the Target's architecture yet, so the ABI is also potentially
-      // incorrect.
+      // Don't use Process::GetABI, this code gets called from DidAttach,
+      // and in that context we haven't set the Target's architecture yet,
+      // so the ABI is also potentially incorrect.
       ABISP abi_to_use_sp = ABI::FindPlugin(shared_from_this(), arch_to_use);
       for (auto &feature_node : feature_nodes) {
         ParseRegisters(feature_node, target_info, this->m_register_info,
@@ -4669,15 +4640,16 @@
                   module.set_link_map(StringConvert::ToUInt64(
                       value.data(), LLDB_INVALID_ADDRESS, 0));
                 } else if (name == "l_addr") {
-                  // the displacement as read from the field 'l_addr' of the
-                  // link_map struct.
+                  // the displacement as read from the field 'l_addr' of
+                  // the link_map struct.
                   module.set_base(StringConvert::ToUInt64(
                       value.data(), LLDB_INVALID_ADDRESS, 0));
-                  // base address is always a displacement, not an absolute
-                  // value.
+                  // base address is always a displacement, not an
+                  // absolute value.
                   module.set_base_is_offset(true);
                 } else if (name == "l_ld") {
-                  // the memory address of the libraries PT_DYAMIC section.
+                  // the memory address of the libraries PT_DYAMIC
+                  // section.
                   module.set_dynamic(StringConvert::ToUInt64(
                       value.data(), LLDB_INVALID_ADDRESS, 0));
                 }
@@ -4739,9 +4711,9 @@
           llvm::StringRef name = library.GetAttributeValue("name");
           module.set_name(name.str());
 
-          // The base address of a given library will be the address of its
-          // first section. Most remotes send only one section for Windows
-          // targets for example.
+          // The base address of a given library will be the address of
+          // its first section. Most remotes send only one section for
+          // Windows targets for example.
           const XMLNode &section =
               library.FindFirstChildElementWithName("section");
           llvm::StringRef address = section.GetAttributeValue("address");
@@ -4837,8 +4809,8 @@
           found = true;
       }
 
-      // The main executable will never be included in libraries-svr4, don't
-      // remove it
+      // The main executable will never be included in libraries-svr4,
+      // don't remove it
       if (!found &&
           loaded_module.get() != target.GetExecutableModulePointer()) {
         removed_modules.Append(loaded_module);
@@ -4916,8 +4888,8 @@
 }
 
 void ProcessGDBRemote::ModulesDidLoad(ModuleList &module_list) {
-  // We must call the lldb_private::Process::ModulesDidLoad () first before we
-  // do anything
+  // We must call the lldb_private::Process::ModulesDidLoad () first
+  // before we do anything
   Process::ModulesDidLoad(module_list);
 
   // After loading shared libraries, we can ask our remote GDB server if
@@ -4979,8 +4951,8 @@
           has_used_usec = true;
           usec_value.getAsInteger(0, curr_used_usec);
         } else {
-          // We didn't find what we want, it is probably
-          // an older version. Bail out.
+          // We didn't find what we want, it is probably an older version.
+          // Bail out.
           profileDataExtractor.SetFilePos(input_file_pos);
         }
       }
@@ -5016,8 +4988,8 @@
           profileDataExtractor.GetNameColonValue(local_name, local_value);
         }
 
-        // Store current time as previous time so that they can be compared
-        // later.
+        // Store current time as previous time so that they can be
+        // compared later.
         new_thread_id_to_used_usec_map[thread_id] = curr_used_usec;
       } else {
         // Bail out and use old string.
Index: source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
===================================================================
--- source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
+++ source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
@@ -80,10 +80,9 @@
 
 const char *ThreadGDBRemote::GetQueueName() {
   // If our cached queue info is valid, then someone called
-  // ThreadGDBRemote::SetQueueInfo(...)
-  // with valid information that was gleaned from the stop reply packet. In this
-  // case we trust
-  // that the info is valid in m_dispatch_queue_name without refetching it
+  // ThreadGDBRemote::SetQueueInfo(...) with valid information that was
+  // gleaned from the stop reply packet. In this case we trust that the
+  // info is valid in m_dispatch_queue_name without refetching it
   if (CachedQueueInfoIsValid()) {
     if (m_dispatch_queue_name.empty())
       return nullptr;
@@ -115,10 +114,9 @@
 
 QueueKind ThreadGDBRemote::GetQueueKind() {
   // If our cached queue info is valid, then someone called
-  // ThreadGDBRemote::SetQueueInfo(...)
-  // with valid information that was gleaned from the stop reply packet. In this
-  // case we trust
-  // that the info is valid in m_dispatch_queue_name without refetching it
+  // ThreadGDBRemote::SetQueueInfo(...) with valid information that was
+  // gleaned from the stop reply packet. In this case we trust that the
+  // info is valid in m_dispatch_queue_name without refetching it
   if (CachedQueueInfoIsValid()) {
     return m_queue_kind;
   }
@@ -141,10 +139,9 @@
 
 queue_id_t ThreadGDBRemote::GetQueueID() {
   // If our cached queue info is valid, then someone called
-  // ThreadGDBRemote::SetQueueInfo(...)
-  // with valid information that was gleaned from the stop reply packet. In this
-  // case we trust
-  // that the info is valid in m_dispatch_queue_name without refetching it
+  // ThreadGDBRemote::SetQueueInfo(...) with valid information that was
+  // gleaned from the stop reply packet. In this case we trust that the
+  // info is valid in m_dispatch_queue_name without refetching it
   if (CachedQueueInfoIsValid())
     return m_queue_serial_number;
 
@@ -272,14 +269,14 @@
 }
 
 void ThreadGDBRemote::RefreshStateAfterStop() {
-  // Invalidate all registers in our register context. We don't set "force" to
-  // true because the stop reply packet might have had some register values
-  // that were expedited and these will already be copied into the register
-  // context by the time this function gets called. The GDBRemoteRegisterContext
-  // class has been made smart enough to detect when it needs to invalidate
-  // which registers are valid by putting hooks in the register read and
-  // register supply functions where they check the process stop ID and do
-  // the right thing.
+  // Invalidate all registers in our register context. We don't set
+  // "force" to true because the stop reply packet might have had some
+  // register values that were expedited and these will already be copied
+  // into the register context by the time this function gets called. The
+  // GDBRemoteRegisterContext class has been made smart enough to detect
+  // when it needs to invalidate which registers are valid by putting
+  // hooks in the register read and register supply functions where they
+  // check the process stop ID and do the right thing.
   const bool force = false;
   GetRegisterContext()->InvalidateIfNeeded(force);
 }
@@ -310,7 +307,8 @@
     if (process_sp) {
       ProcessGDBRemote *gdb_process =
           static_cast<ProcessGDBRemote *>(process_sp.get());
-      // read_all_registers_at_once will be true if 'p' packet is not supported.
+      // read_all_registers_at_once will be true if 'p' packet is not
+      // supported.
       bool read_all_registers_at_once =
           !gdb_process->GetGDBRemote().GetpPacketSupported(GetID());
       reg_ctx_sp.reset(new GDBRemoteRegisterContext(
Index: source/Plugins/Process/mach-core/ProcessMachCore.cpp
===================================================================
--- source/Plugins/Process/mach-core/ProcessMachCore.cpp
+++ source/Plugins/Process/mach-core/ProcessMachCore.cpp
@@ -91,11 +91,10 @@
 
   // For now we are just making sure the file exists for a given module
   if (!m_core_module_sp && m_core_file.Exists()) {
-    // Don't add the Target's architecture to the ModuleSpec - we may be working
-    // with a core file that doesn't have the correct cpusubtype in the header
-    // but we should still try to use it -
-    // ModuleSpecList::FindMatchingModuleSpec
-    // enforces a strict arch mach.
+    // Don't add the Target's architecture to the ModuleSpec - we may be
+    // working with a core file that doesn't have the correct cpusubtype
+    // in the header but we should still try to use it -
+    // ModuleSpecList::FindMatchingModuleSpec enforces a strict arch mach.
     ModuleSpec core_module_spec(m_core_file);
     Status error(ModuleList::GetSharedModule(core_module_spec, m_core_module_sp,
                                              NULL, NULL, NULL));
@@ -162,11 +161,10 @@
   // header.magic, header.filetype);
   if (header.magic == llvm::MachO::MH_MAGIC ||
       header.magic == llvm::MachO::MH_MAGIC_64) {
-    // Check MH_EXECUTABLE to see if we can find the mach image
-    // that contains the shared library list. The dynamic loader
-    // (dyld) is what contains the list for user applications,
-    // and the mach kernel contains a global that has the list
-    // of kexts to load
+    // Check MH_EXECUTABLE to see if we can find the mach image that
+    // contains the shared library list. The dynamic loader (dyld) is what
+    // contains the list for user applications, and the mach kernel
+    // contains a global that has the list of kexts to load
     switch (header.filetype) {
     case llvm::MachO::MH_DYLINKER:
       // printf("0x%16.16" PRIx64 ": file_type = MH_DYLINKER\n", vaddr);
@@ -180,14 +178,15 @@
 
     case llvm::MachO::MH_EXECUTE:
       // printf("0x%16.16" PRIx64 ": file_type = MH_EXECUTE\n", vaddr);
-      // Check MH_EXECUTABLE file types to see if the dynamic link object flag
-      // is NOT set. If it isn't, then we have a mach_kernel.
+      // Check MH_EXECUTABLE file types to see if the dynamic link object
+      // flag is NOT set. If it isn't, then we have a mach_kernel.
       if ((header.flags & llvm::MachO::MH_DYLDLINK) == 0) {
         if (log)
           log->Printf("ProcessMachCore::GetDynamicLoaderAddress found a mach "
                       "kernel binary image at 0x%" PRIx64,
                       addr);
-        // Address of the mach kernel "struct mach_header" in the core file.
+        // Address of the mach kernel "struct mach_header" in the core
+        // file.
         m_mach_kernel_addr = addr;
         return true;
       }
@@ -272,13 +271,10 @@
       } else {
         m_core_aranges.Append(range_entry);
       }
-      // Some core files don't fill in the permissions correctly. If that is the
-      // case
-      // assume read + execute so clients don't think the memory is not
-      // readable,
-      // or executable. The memory isn't writable since this plug-in doesn't
-      // implement
-      // DoWriteMemory.
+      // Some core files don't fill in the permissions correctly. If that
+      // is the case assume read + execute so clients don't think the
+      // memory is not readable, or executable. The memory isn't writable
+      // since this plug-in doesn't implement DoWriteMemory.
       uint32_t permissions = section->GetPermissions();
       if (permissions == 0)
         permissions = lldb::ePermissionsReadable | lldb::ePermissionsExecutable;
@@ -309,8 +305,8 @@
   }
   
   // This checks for the presence of an LC_IDENT string in a core file;
-  // LC_IDENT is very obsolete and should not be used in new code, but
-  // if the load command is present, let's use the contents.
+  // LC_IDENT is very obsolete and should not be used in new code, but if
+  // the load command is present, let's use the contents.
   std::string corefile_identifier = core_objfile->GetIdentifierString();
   if (found_main_binary_definitively == false 
       && corefile_identifier.find("Darwin Kernel") != std::string::npos) {
@@ -342,16 +338,13 @@
   if (found_main_binary_definitively == false
       && (m_dyld_addr == LLDB_INVALID_ADDRESS
           || m_mach_kernel_addr == LLDB_INVALID_ADDRESS)) {
-    // We need to locate the main executable in the memory ranges
-    // we have in the core file.  We need to search for both a user-process dyld
-    // binary
-    // and a kernel binary in memory; we must look at all the pages in the
-    // binary so
-    // we don't miss one or the other.  Step through all memory segments
-    // searching for
-    // a kernel binary and for a user process dyld -- we'll decide which to
-    // prefer
-    // later if both are present.
+    // We need to locate the main executable in the memory ranges we have
+    // in the core file.  We need to search for both a user-process dyld
+    // binary and a kernel binary in memory; we must look at all the pages
+    // in the binary so we don't miss one or the other.  Step through all
+    // memory segments searching for a kernel binary and for a user
+    // process dyld -- we'll decide which to prefer later if both are
+    // present.
 
     const size_t num_core_aranges = m_core_aranges.GetSize();
     for (size_t i = 0; i < num_core_aranges; ++i) {
@@ -369,27 +362,23 @@
   if (found_main_binary_definitively == false 
        && m_mach_kernel_addr != LLDB_INVALID_ADDRESS) {
     // In the case of multiple kernel images found in the core file via
-    // exhaustive
-    // search, we may not pick the correct one.  See if the
-    // DynamicLoaderDarwinKernel's
-    // search heuristics might identify the correct one.
-    // Most of the time, I expect the address from SearchForDarwinKernel() will
-    // be the
-    // same as the address we found via exhaustive search.
+    // exhaustive search, we may not pick the correct one.  See if the
+    // DynamicLoaderDarwinKernel's search heuristics might identify the
+    // correct one. Most of the time, I expect the address from
+    // SearchForDarwinKernel() will be the same as the address we found
+    // via exhaustive search.
 
     if (GetTarget().GetArchitecture().IsValid() == false &&
         m_core_module_sp.get()) {
       GetTarget().SetArchitecture(m_core_module_sp->GetArchitecture());
     }
 
-    // SearchForDarwinKernel will end up calling back into this this class in
-    // the GetImageInfoAddress
-    // method which will give it the m_mach_kernel_addr/m_dyld_addr it already
-    // has.  Save that aside
-    // and set m_mach_kernel_addr/m_dyld_addr to an invalid address temporarily
-    // so
-    // DynamicLoaderDarwinKernel does a real search for the kernel using its own
-    // heuristics.
+    // SearchForDarwinKernel will end up calling back into this this class
+    // in the GetImageInfoAddress method which will give it the
+    // m_mach_kernel_addr/m_dyld_addr it already has.  Save that aside and
+    // set m_mach_kernel_addr/m_dyld_addr to an invalid address
+    // temporarily so DynamicLoaderDarwinKernel does a real search for the
+    // kernel using its own heuristics.
 
     addr_t saved_mach_kernel_addr = m_mach_kernel_addr;
     addr_t saved_user_dyld_addr = m_dyld_addr;
@@ -410,8 +399,8 @@
     }
   }
 
-  // If we found both a user-process dyld and a kernel binary, we need to decide
-  // which to prefer.
+  // If we found both a user-process dyld and a kernel binary, we need to
+  // decide which to prefer.
   if (GetCorefilePreference() == eKernelCorefile) {
     if (m_mach_kernel_addr != LLDB_INVALID_ADDRESS) {
       if (log)
@@ -444,18 +433,14 @@
 
   if (m_dyld_plugin_name != DynamicLoaderMacOSXDYLD::GetPluginNameStatic()) {
     // For non-user process core files, the permissions on the core file
-    // segments are usually
-    // meaningless, they may be just "read", because we're dealing with kernel
-    // coredumps or
-    // early startup coredumps and the dumper is grabbing pages of memory
-    // without knowing
-    // what they are.  If they aren't marked as "exeuctable", that can break the
-    // unwinder
-    // which will check a pc value to see if it is in an executable segment and
-    // stop the
-    // backtrace early if it is not ("executable" and "unknown" would both be
-    // fine, but
-    // "not executable" will break the unwinder).
+    // segments are usually meaningless, they may be just "read", because
+    // we're dealing with kernel coredumps or early startup coredumps and
+    // the dumper is grabbing pages of memory without knowing what they
+    // are.  If they aren't marked as "exeuctable", that can break the
+    // unwinder which will check a pc value to see if it is in an
+    // executable segment and stop the backtrace early if it is not
+    // ("executable" and "unknown" would both be fine, but "not
+    // executable" will break the unwinder).
     size_t core_range_infos_size = m_core_range_infos.GetSize();
     for (size_t i = 0; i < core_range_infos_size; i++) {
       VMRangeToPermissions::Entry *ent =
@@ -464,8 +449,8 @@
     }
   }
 
-  // Even if the architecture is set in the target, we need to override
-  // it to match the core file which is always single arch.
+  // Even if the architecture is set in the target, we need to override it
+  // to match the core file which is always single arch.
   ArchSpec arch(m_core_module_sp->GetArchitecture());
   if (arch.GetCore() == ArchSpec::eCore_x86_32_i486) {
     arch = Platform::GetAugmentedArchSpec(GetTarget().GetPlatform().get(), "i386");
@@ -487,9 +472,8 @@
 bool ProcessMachCore::UpdateThreadList(ThreadList &old_thread_list,
                                        ThreadList &new_thread_list) {
   if (old_thread_list.GetSize(false) == 0) {
-    // Make up the thread the first time this is called so we can setup our one
-    // and only
-    // core thread state.
+    // Make up the thread the first time this is called so we can setup
+    // our one and only core thread state.
     ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
 
     if (core_objfile) {
@@ -508,8 +492,8 @@
 }
 
 void ProcessMachCore::RefreshStateAfterStop() {
-  // Let all threads recover from stopping and do any clean up based
-  // on the previous thread state (if any).
+  // Let all threads recover from stopping and do any clean up based on
+  // the previous thread state (if any).
   m_thread_list.RefreshStateAfterStop();
   // SetThreadStopInfo (m_last_stop_packet);
 }
@@ -541,23 +525,21 @@
 
   if (core_objfile) {
     //----------------------------------------------------------------------
-    // Segments are not always contiguous in mach-o core files. We have core
-    // files that have segments like:
+    // Segments are not always contiguous in mach-o core files. We have
+    // core files that have segments like:
     //            Address    Size       File off   File size
     //            ---------- ---------- ---------- ----------
     // LC_SEGMENT 0x000f6000 0x00001000 0x1d509ee8 0x00001000 --- ---   0
-    // 0x00000000 __TEXT
-    // LC_SEGMENT 0x0f600000 0x00100000 0x1d50aee8 0x00100000 --- ---   0
-    // 0x00000000 __TEXT
-    // LC_SEGMENT 0x000f7000 0x00001000 0x1d60aee8 0x00001000 --- ---   0
-    // 0x00000000 __TEXT
+    // 0x00000000 __TEXT LC_SEGMENT 0x0f600000 0x00100000 0x1d50aee8
+    // 0x00100000 --- ---   0 0x00000000 __TEXT LC_SEGMENT 0x000f7000
+    // 0x00001000 0x1d60aee8 0x00001000 --- ---   0 0x00000000 __TEXT
     //
     // Any if the user executes the following command:
     //
     // (lldb) mem read 0xf6ff0
     //
-    // We would attempt to read 32 bytes from 0xf6ff0 but would only
-    // get 16 unless we loop through consecutive memory ranges that are
+    // We would attempt to read 32 bytes from 0xf6ff0 but would only get
+    // 16 unless we loop through consecutive memory ranges that are
     // contiguous in the address space, but not in the file data.
     //----------------------------------------------------------------------
     while (bytes_read < size) {
@@ -641,8 +623,8 @@
 }
 
 addr_t ProcessMachCore::GetImageInfoAddress() {
-  // If we found both a user-process dyld and a kernel binary, we need to decide
-  // which to prefer.
+  // If we found both a user-process dyld and a kernel binary, we need to
+  // decide which to prefer.
   if (GetCorefilePreference() == eKernelCorefile) {
     if (m_mach_kernel_addr != LLDB_INVALID_ADDRESS) {
       return m_mach_kernel_addr;
Index: source/Plugins/Process/mach-core/ThreadMachCore.cpp
===================================================================
--- source/Plugins/Process/mach-core/ThreadMachCore.cpp
+++ source/Plugins/Process/mach-core/ThreadMachCore.cpp
@@ -48,14 +48,14 @@
 }
 
 void ThreadMachCore::RefreshStateAfterStop() {
-  // Invalidate all registers in our register context. We don't set "force" to
-  // true because the stop reply packet might have had some register values
-  // that were expedited and these will already be copied into the register
-  // context by the time this function gets called. The KDPRegisterContext
-  // class has been made smart enough to detect when it needs to invalidate
-  // which registers are valid by putting hooks in the register read and
-  // register supply functions where they check the process stop ID and do
-  // the right thing.
+  // Invalidate all registers in our register context. We don't set
+  // "force" to true because the stop reply packet might have had some
+  // register values that were expedited and these will already be copied
+  // into the register context by the time this function gets called. The
+  // KDPRegisterContext class has been made smart enough to detect when it
+  // needs to invalidate which registers are valid by putting hooks in the
+  // register read and register supply functions where they check the
+  // process stop ID and do the right thing.
   const bool force = false;
   GetRegisterContext()->InvalidateIfNeeded(force);
 }
Index: source/Plugins/Process/minidump/MinidumpParser.cpp
===================================================================
--- source/Plugins/Process/minidump/MinidumpParser.cpp
+++ source/Plugins/Process/minidump/MinidumpParser.cpp
@@ -115,12 +115,12 @@
 
 llvm::ArrayRef<uint8_t>
 MinidumpParser::GetThreadContextWow64(const MinidumpThread &td) {
-  // On Windows, a 32-bit process can run on a 64-bit machine under
-  // WOW64. If the minidump was captured with a 64-bit debugger, then
-  // the CONTEXT we just grabbed from the mini_dump_thread is the one
-  // for the 64-bit "native" process rather than the 32-bit "guest"
-  // process we care about.  In this case, we can get the 32-bit CONTEXT
-  // from the TEB (Thread Environment Block) of the 64-bit process.
+  // On Windows, a 32-bit process can run on a 64-bit machine under WOW64.
+  // If the minidump was captured with a 64-bit debugger, then the CONTEXT
+  // we just grabbed from the mini_dump_thread is the one for the 64-bit
+  // "native" process rather than the 32-bit "guest" process we care
+  // about.  In this case, we can get the 32-bit CONTEXT from the TEB
+  // (Thread Environment Block) of the 64-bit process.
   auto teb_mem = GetMemory(td.teb, sizeof(TEB64));
   if (teb_mem.empty())
     return {};
@@ -131,16 +131,16 @@
     return {};
 
   // Slot 1 of the thread-local storage in the 64-bit TEB points to a
-  // structure that includes the 32-bit CONTEXT (after a ULONG).
-  // See:  https://msdn.microsoft.com/en-us/library/ms681670.aspx
+  // structure that includes the 32-bit CONTEXT (after a ULONG). See:
+  // https://msdn.microsoft.com/en-us/library/ms681670.aspx
   auto context =
       GetMemory(wow64teb->tls_slots[1] + 4, sizeof(MinidumpContext_x86_32));
   if (context.size() < sizeof(MinidumpContext_x86_32))
     return {};
 
   return context;
-  // NOTE:  We don't currently use the TEB for anything else.  If we
-  // need it in the future, the 32-bit TEB is located according to the address
+  // NOTE:  We don't currently use the TEB for anything else.  If we need
+  // it in the future, the 32-bit TEB is located according to the address
   // stored in the first slot of the 64-bit TEB (wow64teb.Reserved1[0]).
 }
 
@@ -160,8 +160,8 @@
   if (!system_info)
     return arch_spec;
 
-  // TODO what to do about big endiand flavors of arm ?
-  // TODO set the arm subarch stuff if the minidump has info about it
+  // TODO what to do about big endiand flavors of arm ? TODO set the arm
+  // subarch stuff if the minidump has info about it
 
   llvm::Triple triple;
   triple.setVendor(llvm::Triple::VendorType::UnknownVendor);
@@ -262,7 +262,8 @@
 
 std::vector<const MinidumpModule *> MinidumpParser::GetFilteredModuleList() {
   llvm::ArrayRef<MinidumpModule> modules = GetModuleList();
-  // map module_name -> pair(load_address, pointer to module struct in memory)
+  // map module_name -> pair(load_address, pointer to module struct in
+  // memory)
   llvm::StringMap<std::pair<uint64_t, const MinidumpModule *>> lowest_addr;
 
   std::vector<const MinidumpModule *> filtered_modules;
@@ -335,9 +336,9 @@
   }
 
   // Some Minidumps have a Memory64ListStream that captures all the heap
-  // memory (full-memory Minidumps).  We can't exactly use the same loop as
-  // above, because the Minidump uses slightly different data structures to
-  // describe those
+  // memory (full-memory Minidumps).  We can't exactly use the same loop
+  // as above, because the Minidump uses slightly different data
+  // structures to describe those
 
   if (!data64.empty()) {
     llvm::ArrayRef<MinidumpMemoryDescriptor64> memory64_list;
@@ -368,17 +369,17 @@
 
 llvm::ArrayRef<uint8_t> MinidumpParser::GetMemory(lldb::addr_t addr,
                                                   size_t size) {
-  // I don't have a sense of how frequently this is called or how many memory
-  // ranges a Minidump typically has, so I'm not sure if searching for the
-  // appropriate range linearly each time is stupid.  Perhaps we should build
-  // an index for faster lookups.
+  // I don't have a sense of how frequently this is called or how many
+  // memory ranges a Minidump typically has, so I'm not sure if searching
+  // for the appropriate range linearly each time is stupid.  Perhaps we
+  // should build an index for faster lookups.
   llvm::Optional<minidump::Range> range = FindMemoryRange(addr);
   if (!range)
     return {};
 
-  // There's at least some overlap between the beginning of the desired range
-  // (addr) and the current range.  Figure out where the overlap begins and
-  // how much overlap there is.
+  // There's at least some overlap between the beginning of the desired
+  // range (addr) and the current range.  Figure out where the overlap
+  // begins and how much overlap there is.
 
   const size_t offset = addr - range->start;
 
@@ -436,13 +437,14 @@
     } else if (head > load_addr &&
                (next_entry == nullptr || head < next_entry->base_address)) {
       // In case there is no region containing load_addr keep track of the
-      // nearest region after load_addr so we can return the distance to it.
+      // nearest region after load_addr so we can return the distance to
+      // it.
       next_entry = entry;
     }
   }
 
-  // No containing region found. Create an unmapped region that extends to the
-  // next region or LLDB_INVALID_ADDRESS
+  // No containing region found. Create an unmapped region that extends to
+  // the next region or LLDB_INVALID_ADDRESS
   info.GetRange().SetRangeBase(load_addr);
   info.GetRange().SetRangeEnd((next_entry != nullptr) ? next_entry->base_address
                                                       : LLDB_INVALID_ADDRESS);
@@ -451,8 +453,8 @@
   info.SetExecutable(no);
   info.SetMapped(no);
 
-  // Note that the memory info list doesn't seem to contain ranges in kernel
-  // space, so if you're walking a stack that has kernel frames, the stack may
-  // appear truncated.
+  // Note that the memory info list doesn't seem to contain ranges in
+  // kernel space, so if you're walking a stack that has kernel frames,
+  // the stack may appear truncated.
   return info;
 }
Index: source/Plugins/Process/minidump/MinidumpTypes.cpp
===================================================================
--- source/Plugins/Process/minidump/MinidumpTypes.cpp
+++ source/Plugins/Process/minidump/MinidumpTypes.cpp
@@ -55,9 +55,8 @@
     return llvm::None;
 
   auto source_start = reinterpret_cast<const llvm::UTF16 *>(data.data());
-  // source_length is the length of the string in bytes
-  // we need the length of the string in UTF-16 characters/code points (16 bits
-  // per char)
+  // source_length is the length of the string in bytes we need the length
+  // of the string in UTF-16 characters/code points (16 bits per char)
   // that's why it's divided by 2
   const auto source_end = source_start + source_length / 2;
   // resize to worst case length
Index: source/Plugins/Process/minidump/ProcessMinidump.cpp
===================================================================
--- source/Plugins/Process/minidump/ProcessMinidump.cpp
+++ source/Plugins/Process/minidump/ProcessMinidump.cpp
@@ -315,8 +315,8 @@
                   uint32_t(module->size_of_image));
     }
 
-    // check if the process is wow64 - a 32 bit windows process running on a
-    // 64 bit windows
+    // check if the process is wow64 - a 32 bit windows process running on
+    // a 64 bit windows
     if (llvm::StringRef(name.getValue()).endswith_lower("wow64.dll")) {
       m_is_wow64 = true;
     }
@@ -328,8 +328,8 @@
     lldb::ModuleSP module_sp = GetTarget().GetSharedModule(module_spec, &error);
     if (!module_sp || error.Fail()) {
       // We failed to locate a matching local object file. Fortunately,
-      // the minidump format encodes enough information about each module's
-      // memory range to allow us to create placeholder modules.
+      // the minidump format encodes enough information about each
+      // module's memory range to allow us to create placeholder modules.
       //
       // This enables most LLDB functionality involving address-to-module
       // translations (ex. identifing the module for a stack frame PC) and
Index: source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp
===================================================================
--- source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp
+++ source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp
@@ -117,32 +117,32 @@
     return result;
   }
 
-  // There was a dot.  The remaining portion of the name should be looked up in
-  // the context of the object that was found in the dictionary.
+  // There was a dot.  The remaining portion of the name should be looked
+  // up in the context of the object that was found in the dictionary.
   return result.ResolveName(name.substr(dot_pos + 1));
 }
 
 PythonObject PythonObject::ResolveName(llvm::StringRef name) const {
-  // Resolve the name in the context of the specified object.  If,
-  // for example, `this` refers to a PyModule, then this will look for
-  // `name` in this module.  If `this` refers to a PyType, then it will
-  // resolve `name` as an attribute of that type.  If `this` refers to
-  // an instance of an object, then it will resolve `name` as the value
-  // of the specified field.
+  // Resolve the name in the context of the specified object.  If, for
+  // example, `this` refers to a PyModule, then this will look for `name`
+  // in this module.  If `this` refers to a PyType, then it will resolve
+  // `name` as an attribute of that type.  If `this` refers to an instance
+  // of an object, then it will resolve `name` as the value of the
+  // specified field.
   //
-  // This function handles dotted names so that, for example, if `m_py_obj`
-  // refers to the `sys` module, and `name` == "path.append", then it
-  // will find the function `sys.path.append`.
+  // This function handles dotted names so that, for example, if
+  // `m_py_obj` refers to the `sys` module, and `name` == "path.append",
+  // then it will find the function `sys.path.append`.
 
   size_t dot_pos = name.find_first_of('.');
   if (dot_pos == llvm::StringRef::npos) {
-    // No dots in the name, we should be able to find the value immediately
-    // as an attribute of `m_py_obj`.
+    // No dots in the name, we should be able to find the value
+    // immediately as an attribute of `m_py_obj`.
     return GetAttributeValue(name);
   }
 
-  // Look up the first piece of the name, and resolve the rest as a child of
-  // that.
+  // Look up the first piece of the name, and resolve the rest as a child
+  // of that.
   PythonObject parent = ResolveName(name.substr(0, dot_pos));
   if (!parent.IsAllocated())
     return PythonObject();
@@ -240,8 +240,7 @@
   }
 
   // Calling PythonObject::Reset(const PythonObject&) will lead to stack
-  // overflow since it calls
-  // back into the virtual implementation.
+  // overflow since it calls back into the virtual implementation.
   PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
@@ -313,8 +312,7 @@
   }
 
   // Calling PythonObject::Reset(const PythonObject&) will lead to stack
-  // overflow since it calls
-  // back into the virtual implementation.
+  // overflow since it calls back into the virtual implementation.
   PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
@@ -394,8 +392,7 @@
     result.Reset(PyRefType::Owned, PyUnicode_AsUTF8String(result.get()));
 #endif
   // Calling PythonObject::Reset(const PythonObject&) will lead to stack
-  // overflow since it calls
-  // back into the virtual implementation.
+  // overflow since it calls back into the virtual implementation.
   PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
@@ -490,8 +487,8 @@
   // since 3.x doesn't even have a PyInt.
   if (PyInt_Check(py_obj)) {
     // Since we converted the original object to a different type, the new
-    // object is an owned object regardless of the ownership semantics requested
-    // by the user.
+    // object is an owned object regardless of the ownership semantics
+    // requested by the user.
     result.Reset(PyRefType::Owned, PyLong_FromLongLong(PyInt_AsLong(py_obj)));
   }
 #endif
@@ -500,8 +497,7 @@
          "Couldn't get a PyLong from this PyObject");
 
   // Calling PythonObject::Reset(const PythonObject&) will lead to stack
-  // overflow since it calls
-  // back into the virtual implementation.
+  // overflow since it calls back into the virtual implementation.
   PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
@@ -513,10 +509,10 @@
     int overflow = 0;
     int64_t result = PyLong_AsLongLongAndOverflow(m_py_obj, &overflow);
     if (overflow != 0) {
-      // We got an integer that overflows, like 18446744072853913392L
-      // we can't use PyLong_AsLongLong() as it will return
-      // 0xffffffffffffffff. If we use the unsigned long long
-      // it will work as expected.
+      // We got an integer that overflows, like 18446744072853913392L we
+      // can't use PyLong_AsLongLong() as it will return
+      // 0xffffffffffffffff. If we use the unsigned long long it will work
+      // as expected.
       const uint64_t uval = PyLong_AsUnsignedLongLong(m_py_obj);
       result = static_cast<int64_t>(uval);
     }
@@ -573,8 +569,7 @@
   }
 
   // Calling PythonObject::Reset(const PythonObject&) will lead to stack
-  // overflow since it calls
-  // back into the virtual implementation.
+  // overflow since it calls back into the virtual implementation.
   PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
@@ -601,8 +596,8 @@
 
 void PythonList::AppendItem(const PythonObject &object) {
   if (IsAllocated() && object.IsValid()) {
-    // `PyList_Append` does *not* steal a reference, so do not call `Py_INCREF`
-    // here like we do with `PyList_SetItem`.
+    // `PyList_Append` does *not* steal a reference, so do not call
+    // `Py_INCREF` here like we do with `PyList_SetItem`.
     PyList_Append(m_py_obj, object.get());
   }
 }
@@ -678,8 +673,7 @@
   }
 
   // Calling PythonObject::Reset(const PythonObject&) will lead to stack
-  // overflow since it calls
-  // back into the virtual implementation.
+  // overflow since it calls back into the virtual implementation.
   PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
@@ -751,8 +745,7 @@
   }
 
   // Calling PythonObject::Reset(const PythonObject&) will lead to stack
-  // overflow since it calls
-  // back into the virtual implementation.
+  // overflow since it calls back into the virtual implementation.
   PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
@@ -843,8 +836,7 @@
   }
 
   // Calling PythonObject::Reset(const PythonObject&) will lead to stack
-  // overflow since it calls
-  // back into the virtual implementation.
+  // overflow since it calls back into the virtual implementation.
   PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
@@ -881,8 +873,7 @@
   }
 
   // Calling PythonObject::Reset(const PythonObject&) will lead to stack
-  // overflow since it calls
-  // back into the virtual implementation.
+  // overflow since it calls back into the virtual implementation.
   PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
@@ -961,13 +952,14 @@
 #if PY_MAJOR_VERSION < 3
   return PyFile_Check(py_obj);
 #else
-  // In Python 3, there is no `PyFile_Check`, and in fact PyFile is not even a
-  // first-class object type anymore.  `PyFile_FromFd` is just a thin wrapper
-  // over `io.open()`, which returns some object derived from `io.IOBase`.
-  // As a result, the only way to detect a file in Python 3 is to check whether
-  // it inherits from `io.IOBase`.  Since it is possible for non-files to also
-  // inherit from `io.IOBase`, we additionally verify that it has the `fileno`
-  // attribute, which should guarantee that it is backed by the file system.
+  // In Python 3, there is no `PyFile_Check`, and in fact PyFile is not
+  // even a first-class object type anymore.  `PyFile_FromFd` is just a
+  // thin wrapper over `io.open()`, which returns some object derived from
+  // `io.IOBase`. As a result, the only way to detect a file in Python 3
+  // is to check whether it inherits from `io.IOBase`.  Since it is
+  // possible for non-files to also inherit from `io.IOBase`, we
+  // additionally verify that it has the `fileno` attribute, which should
+  // guarantee that it is backed by the file system.
   PythonObject io_module(PyRefType::Owned, PyImport_ImportModule("io"));
   PythonDictionary io_dict(PyRefType::Borrowed,
                            PyModule_GetDict(io_module.get()));
@@ -1039,8 +1031,8 @@
     return false;
 
   file.Close();
-  // We don't own the file descriptor returned by this function, make sure the
-  // File object knows about that.
+  // We don't own the file descriptor returned by this function, make sure
+  // the File object knows about that.
   file.SetDescriptor(PyObject_AsFileDescriptor(m_py_obj), false);
   PythonString py_mode = GetAttributeValue("mode").AsType<PythonString>();
   file.SetOptions(PythonFile::GetOptionsFromMode(py_mode.GetString()));
Index: source/Plugins/ScriptInterpreter/Python/PythonExceptionState.cpp
===================================================================
--- source/Plugins/ScriptInterpreter/Python/PythonExceptionState.cpp
+++ source/Plugins/ScriptInterpreter/Python/PythonExceptionState.cpp
@@ -31,8 +31,8 @@
 
 void PythonExceptionState::Acquire(bool restore_on_exit) {
   // If a state is already acquired, the user needs to decide whether they
-  // want to discard or restore it.  Don't allow the potential silent
-  // loss of a valid state.
+  // want to discard or restore it.  Don't allow the potential silent loss
+  // of a valid state.
   assert(!IsError());
 
   if (!HasErrorOccurred())
@@ -45,8 +45,8 @@
   // PyErr_Fetch clears the error flag.
   assert(!HasErrorOccurred());
 
-  // Ownership of the objects returned by `PyErr_Fetch` is transferred
-  // to us.
+  // Ownership of the objects returned by `PyErr_Fetch` is transferred to
+  // us.
   m_type.Reset(PyRefType::Owned, py_type);
   m_value.Reset(PyRefType::Owned, py_value);
   m_traceback.Reset(PyRefType::Owned, py_traceback);
@@ -55,15 +55,15 @@
 
 void PythonExceptionState::Restore() {
   if (m_type.IsValid()) {
-    // The documentation for PyErr_Restore says "Do not pass a null type and
-    // non-null value or traceback.  So only restore if type was non-null
-    // to begin with.  In this case we're passing ownership back to Python
-    // so release them all.
+    // The documentation for PyErr_Restore says "Do not pass a null type
+    // and non-null value or traceback.  So only restore if type was non-
+    // null to begin with.  In this case we're passing ownership back to
+    // Python so release them all.
     PyErr_Restore(m_type.release(), m_value.release(), m_traceback.release());
   }
 
-  // After we restore, we should not hold onto the exception state.  Demand that
-  // it be re-acquired.
+  // After we restore, we should not hold onto the exception state.
+  // Demand that it be re-acquired.
   Discard();
 }
 
Index: source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
===================================================================
--- source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
+++ source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
@@ -112,26 +112,27 @@
 
 namespace {
 
-// Initializing Python is not a straightforward process.  We cannot control what
-// external code may have done before getting to this point in LLDB, including
-// potentially having already initialized Python, so we need to do a lot of work
-// to ensure that the existing state of the system is maintained across our
-// initialization.  We do this by using an RAII pattern where we save off
-// initial
-// state at the beginning, and restore it at the end
+// Initializing Python is not a straightforward process.  We cannot
+// control what external code may have done before getting to this point
+// in LLDB, including potentially having already initialized Python, so we
+// need to do a lot of work to ensure that the existing state of the
+// system is maintained across our initialization.  We do this by using an
+// RAII pattern where we save off initial state at the beginning, and
+// restore it at the end
 struct InitializePythonRAII {
 public:
   InitializePythonRAII()
       : m_gil_state(PyGILState_UNLOCKED), m_was_already_initialized(false) {
-    // Python will muck with STDIN terminal state, so save off any current TTY
-    // settings so we can restore them.
+    // Python will muck with STDIN terminal state, so save off any current
+    // TTY settings so we can restore them.
     m_stdin_tty_state.Save(STDIN_FILENO, false);
 
     InitializePythonHome();
 
 // Python < 3.2 and Python >= 3.2 reversed the ordering requirements for
-// calling `Py_Initialize` and `PyEval_InitThreads`.  < 3.2 requires that you
-// call `PyEval_InitThreads` first, and >= 3.2 requires that you call it last.
+// calling `Py_Initialize` and `PyEval_InitThreads`.  < 3.2 requires that
+// you call `PyEval_InitThreads` first, and >= 3.2 requires that you call
+// it last.
 #if (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 2) || (PY_MAJOR_VERSION > 3)
     Py_InitializeEx(0);
     InitializeThreadsPrivate();
@@ -212,10 +213,10 @@
 
   // we need to save the thread state when we first start the command
   // because we might decide to interrupt it while some action is taking
-  // place outside of Python (e.g. printing to screen, waiting for the network,
-  // ...)
-  // in that case, _PyThreadState_Current will be NULL - and we would be unable
-  // to set the asynchronous exception - not a desirable situation
+  // place outside of Python (e.g. printing to screen, waiting for the
+  // network, ...) in that case, _PyThreadState_Current will be NULL - and
+  // we would be unable to set the asynchronous exception - not a
+  // desirable situation
   m_python_interpreter->SetThreadState(PyThreadState_Get());
   m_python_interpreter->IncrementLockCount();
   return true;
@@ -280,18 +281,18 @@
       m_dictionary_name.c_str());
   PyRun_SimpleString(run_string.GetData());
 
-  // Reloading modules requires a different syntax in Python 2 and Python 3.
-  // This provides
-  // a consistent syntax no matter what version of Python.
+  // Reloading modules requires a different syntax in Python 2 and Python
+  // 3. This provides a consistent syntax no matter what version of
+  // Python.
   run_string.Clear();
   run_string.Printf("run_one_line (%s, 'from six.moves import reload_module')",
                     m_dictionary_name.c_str());
   PyRun_SimpleString(run_string.GetData());
 
-  // WARNING: temporary code that loads Cocoa formatters - this should be done
-  // on a per-platform basis rather than loading the whole set
-  // and letting the individual formatter classes exploit APIs to check whether
-  // they can/cannot do their task
+  // WARNING: temporary code that loads Cocoa formatters - this should be
+  // done on a per-platform basis rather than loading the whole set and
+  // letting the individual formatter classes exploit APIs to check
+  // whether they can/cannot do their task
   run_string.Clear();
   run_string.Printf(
       "run_one_line (%s, 'import lldb.formatters, lldb.formatters.cpp, pydoc')",
@@ -314,12 +315,11 @@
 }
 
 ScriptInterpreterPython::~ScriptInterpreterPython() {
-  // the session dictionary may hold objects with complex state
-  // which means that they may need to be torn down with some level of smarts
-  // and that, in turn, requires a valid thread state
-  // force Python to procure itself such a thread state, nuke the session
-  // dictionary
-  // and then release it for others to use and proceed with the rest of the
+  // the session dictionary may hold objects with complex state which
+  // means that they may need to be torn down with some level of smarts
+  // and that, in turn, requires a valid thread state force Python to
+  // procure itself such a thread state, nuke the session dictionary and
+  // then release it for others to use and proceed with the rest of the
   // shutdown
   auto gil_state = PyGILState_Ensure();
   m_session_dict.Reset();
@@ -450,18 +450,18 @@
 void ScriptInterpreterPython::ResetOutputFileHandle(FILE *fh) {}
 
 void ScriptInterpreterPython::SaveTerminalState(int fd) {
-  // Python mucks with the terminal state of STDIN. If we can possibly avoid
-  // this by setting the file handles up correctly prior to entering the
-  // interpreter we should. For now we save and restore the terminal state
-  // on the input file handle.
+  // Python mucks with the terminal state of STDIN. If we can possibly
+  // avoid this by setting the file handles up correctly prior to entering
+  // the interpreter we should. For now we save and restore the terminal
+  // state on the input file handle.
   m_terminal_state.Save(fd, false);
 }
 
 void ScriptInterpreterPython::RestoreTerminalState() {
-  // Python mucks with the terminal state of STDIN. If we can possibly avoid
-  // this by setting the file handles up correctly prior to entering the
-  // interpreter we should. For now we save and restore the terminal state
-  // on the input file handle.
+  // Python mucks with the terminal state of STDIN. If we can possibly
+  // avoid this by setting the file handles up correctly prior to entering
+  // the interpreter we should. For now we save and restore the terminal
+  // state on the input file handle.
   m_terminal_state.Restore();
 }
 
@@ -470,18 +470,16 @@
   if (log)
     log->PutCString("ScriptInterpreterPython::LeaveSession()");
 
-  // checking that we have a valid thread state - since we use our own threading
-  // and locking
-  // in some (rare) cases during cleanup Python may end up believing we have no
-  // thread state
-  // and PyImport_AddModule will crash if that is the case - since that seems to
-  // only happen
-  // when destroying the SBDebugger, we can make do without clearing up stdout
+  // checking that we have a valid thread state - since we use our own
+  // threading and locking in some (rare) cases during cleanup Python may
+  // end up believing we have no thread state and PyImport_AddModule will
+  // crash if that is the case - since that seems to only happen when
+  // destroying the SBDebugger, we can make do without clearing up stdout
   // and stderr
 
   // rdar://problem/11292882
-  // When the current thread state is NULL, PyThreadState_Get() issues a fatal
-  // error.
+  // When the current thread state is NULL, PyThreadState_Get() issues a
+  // fatal error.
   if (PyThreadState_GetDict()) {
     PythonDictionary &sys_module_dict = GetSysModuleDictionary();
     if (sys_module_dict.IsValid()) {
@@ -507,7 +505,8 @@
                                            PythonFile &save_file,
                                            const char *mode) {
   if (file.IsValid()) {
-    // Flush the file before giving it to python to avoid interleaved output.
+    // Flush the file before giving it to python to avoid interleaved
+    // output.
     file.Flush();
 
     PythonDictionary &sys_module_dict = GetSysModuleDictionary();
@@ -525,9 +524,8 @@
 
 bool ScriptInterpreterPython::EnterSession(uint16_t on_entry_flags, FILE *in,
                                            FILE *out, FILE *err) {
-  // If we have already entered the session, without having officially 'left'
-  // it, then there is no need to
-  // 'enter' it again.
+  // If we have already entered the session, without having officially
+  // 'left' it, then there is no need to 'enter' it again.
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
   if (m_session_is_active) {
     if (log)
@@ -560,8 +558,8 @@
     run_string.PutCString("; lldb.frame = lldb.thread.GetSelectedFrame ()");
     run_string.PutCString("')");
   } else {
-    // If we aren't initing the globals, we should still always set the debugger
-    // (since that is always unique.)
+    // If we aren't initing the globals, we should still always set the
+    // debugger (since that is always unique.)
     run_string.Printf("run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64,
                       m_dictionary_name.c_str(),
                       GetCommandInterpreter().GetDebugger().GetID());
@@ -701,12 +699,11 @@
     return false;
 
   if (command && command[0]) {
-    // We want to call run_one_line, passing in the dictionary and the command
-    // string.  We cannot do this through
-    // PyRun_SimpleString here because the command string may contain escaped
-    // characters, and putting it inside
-    // another string to pass to PyRun_SimpleString messes up the escaping.  So
-    // we use the following more complicated
+    // We want to call run_one_line, passing in the dictionary and the
+    // command string.  We cannot do this through PyRun_SimpleString here
+    // because the command string may contain escaped characters, and
+    // putting it inside another string to pass to PyRun_SimpleString
+    // messes up the escaping.  So we use the following more complicated
     // method to pass the command string directly down to Python.
     Debugger &debugger = m_interpreter.GetDebugger();
 
@@ -719,8 +716,8 @@
     if (options.GetEnableIO()) {
       if (result) {
         input_file_sp = debugger.GetInputFile();
-        // Set output to a temporary file so we can forward the results on to
-        // the result object
+        // Set output to a temporary file so we can forward the results on
+        // to the result object
 
         Pipe pipe;
         Status pipe_result = pipe.CreateNew(false);
@@ -773,17 +770,14 @@
     FILE *err_file = error_file_sp->GetFile().GetStream();
     bool success = false;
     {
-      // WARNING!  It's imperative that this RAII scope be as tight as possible.
-      // In particular, the
-      // scope must end *before* we try to join the read thread.  The reason for
-      // this is that a
-      // pre-requisite for joining the read thread is that we close the write
-      // handle (to break the
-      // pipe and cause it to wake up and exit).  But acquiring the GIL as below
-      // will redirect Python's
-      // stdio to use this same handle.  If we close the handle while Python is
-      // still using it, bad
-      // things will happen.
+      // WARNING!  It's imperative that this RAII scope be as tight as
+      // possible. In particular, the scope must end *before* we try to
+      // join the read thread.  The reason for this is that a pre-
+      // requisite for joining the read thread is that we close the write
+      // handle (to break the pipe and cause it to wake up and exit).  But
+      // acquiring the GIL as below will redirect Python's stdio to use
+      // this same handle.  If we close the handle while Python is still
+      // using it, bad things will happen.
       Locker locker(
           this,
           ScriptInterpreterPython::Locker::AcquireLock |
@@ -796,7 +790,8 @@
               ScriptInterpreterPython::Locker::TearDownSession,
           in_file, out_file, err_file);
 
-      // Find the correct script interpreter dictionary in the main module.
+      // Find the correct script interpreter dictionary in the main
+      // module.
       PythonDictionary &session_dict = GetSessionDictionary();
       if (session_dict.IsValid()) {
         if (GetEmbeddedInterpreterModuleObjects()) {
@@ -827,12 +822,12 @@
     }
 
     if (join_read_thread) {
-      // Close the write end of the pipe since we are done with our
-      // one line script. This should cause the read thread that
-      // output_comm is using to exit
+      // Close the write end of the pipe since we are done with our one
+      // line script. This should cause the read thread that output_comm
+      // is using to exit
       output_file_sp->GetFile().Close();
-      // The close above should cause this thread to exit when it gets
-      // to the end of file, so let it get all its data
+      // The close above should cause this thread to exit when it gets to
+      // the end of file, so let it get all its data
       output_comm.JoinReadThread();
       // Now we can close the read end of the pipe
       output_comm.Disconnect();
@@ -889,21 +884,18 @@
             ScriptInterpreterPython::Locker::FreeAcquiredLock |
                 ScriptInterpreterPython::Locker::TearDownSession);
 
-        // The following call drops into the embedded interpreter loop and stays
-        // there until the
-        // user chooses to exit from the Python interpreter.
-        // This embedded interpreter will, as any Python code that performs I/O,
-        // unlock the GIL before
-        // a system call that can hang, and lock it when the syscall has
-        // returned.
-
-        // We need to surround the call to the embedded interpreter with calls
-        // to PyGILState_Ensure and
-        // PyGILState_Release (using the Locker above). This is because Python
-        // has a global lock which must be held whenever we want
-        // to touch any Python objects. Otherwise, if the user calls Python
-        // code, the interpreter state will be off,
-        // and things could hang (it's happened before).
+        // The following call drops into the embedded interpreter loop and
+        // stays there until the user chooses to exit from the Python
+        // interpreter. This embedded interpreter will, as any Python code
+        // that performs I/O, unlock the GIL before a system call that can
+        // hang, and lock it when the syscall has returned.
+
+        // We need to surround the call to the embedded interpreter with
+        // calls to PyGILState_Ensure and PyGILState_Release (using the
+        // Locker above). This is because Python has a global lock which
+        // must be held whenever we want to touch any Python objects.
+        // Otherwise, if the user calls Python code, the interpreter state
+        // will be off, and things could hang (it's happened before).
 
         StreamString run_string;
         run_string.Printf("run_python_interpreter (%s)",
@@ -934,12 +926,10 @@
   Debugger &debugger = GetCommandInterpreter().GetDebugger();
 
   // At the moment, the only time the debugger does not have an input file
-  // handle is when this is called
-  // directly from Python, in which case it is both dangerous and unnecessary
-  // (not to mention confusing) to
-  // try to embed a running interpreter loop inside the already running Python
-  // interpreter loop, so we won't
-  // do it.
+  // handle is when this is called directly from Python, in which case it
+  // is both dangerous and unnecessary (not to mention confusing) to try
+  // to embed a running interpreter loop inside the already running Python
+  // interpreter loop, so we won't do it.
 
   if (!debugger.GetInputFile()->GetFile().IsValid())
     return;
@@ -1011,7 +1001,8 @@
 
   if (in_string != nullptr) {
     { // scope for PythonInputReaderManager
-      // PythonInputReaderManager py_input(options.GetEnableIO() ? this : NULL);
+      // PythonInputReaderManager py_input(options.GetEnableIO() ? this :
+      // NULL);
       py_return.Reset(
           PyRefType::Owned,
           PyRun_String(in_string, Py_eval_input, globals.get(), locals.get()));
@@ -1173,11 +1164,9 @@
                       Py_CompileString(in_string, "temp.py", Py_file_input));
 
     if (code_object.IsValid()) {
-// In Python 2.x, PyEval_EvalCode takes a PyCodeObject, but in Python 3.x, it
-// takes
-// a PyObject.  They are convertible (hence the function
-// PyCode_Check(PyObject*), so
-// we have to do the cast for Python 2.x
+// In Python 2.x, PyEval_EvalCode takes a PyCodeObject, but in Python 3.x,
+// it takes a PyObject.  They are convertible (hence the function
+// PyCode_Check(PyObject*), so we have to do the cast for Python 2.x
 #if PY_MAJOR_VERSION >= 3
       PyObject *py_code_obj = code_object.get();
 #else
@@ -1243,10 +1232,9 @@
   auto data_ap = llvm::make_unique<CommandDataPython>();
 
   // Split the command_body_text into lines, and pass that to
-  // GenerateBreakpointCommandCallbackData.  That will
-  // wrap the body in an auto-generated function, and return the function name
-  // in script_source.  That is what
-  // the callback will actually invoke.
+  // GenerateBreakpointCommandCallbackData.  That will wrap the body in an
+  // auto-generated function, and return the function name in
+  // script_source.  That is what the callback will actually invoke.
 
   data_ap->user_source.SplitIntoLines(command_body_text);
   Status error = GenerateBreakpointCommandCallbackData(data_ap->user_source,
@@ -1266,11 +1254,10 @@
     WatchpointOptions *wp_options, const char *oneliner) {
   auto data_ap = llvm::make_unique<WatchpointOptions::CommandData>();
 
-  // It's necessary to set both user_source and script_source to the oneliner.
-  // The former is used to generate callback description (as in watchpoint
-  // command list)
-  // while the latter is used for Python to interpret during the actual
-  // callback.
+  // It's necessary to set both user_source and script_source to the
+  // oneliner. The former is used to generate callback description (as in
+  // watchpoint command list) while the latter is used for Python to
+  // interpret during the actual callback.
 
   data_ap->user_source.AppendString(oneliner);
   data_ap->script_source.assign(oneliner);
@@ -1364,9 +1351,9 @@
   if (user_input.GetSize() == 0)
     return false;
 
-  // Take what the user wrote, wrap it all up inside one big auto-generated
-  // Python function, passing in the
-  // ValueObject as parameter to the function.
+  // Take what the user wrote, wrap it all up inside one big auto-
+  // generated Python function, passing in the ValueObject as parameter to
+  // the function.
 
   std::string auto_generated_function_name(
       GenerateUniqueName("lldb_autogen_python_type_print_func",
@@ -1430,19 +1417,18 @@
   sstr.Printf("class %s:", auto_generated_class_name.c_str());
   auto_generated_class.AppendString(sstr.GetString());
 
-  // Wrap everything up inside the class, increasing the indentation.
-  // we don't need to play any fancy indentation tricks here because there is no
-  // surrounding code whose indentation we need to honor
+  // Wrap everything up inside the class, increasing the indentation. we
+  // don't need to play any fancy indentation tricks here because there is
+  // no surrounding code whose indentation we need to honor
   for (int i = 0; i < num_lines; ++i) {
     sstr.Clear();
     sstr.Printf("     %s", user_input.GetStringAtIndex(i));
     auto_generated_class.AppendString(sstr.GetString());
   }
 
-  // Verify that the results are valid Python.
-  // (even though the method is ExportFunctionDefinitionToInterpreter, a class
-  // will actually be exported)
-  // (TODO: rename that method to ExportDefinitionToInterpreter)
+  // Verify that the results are valid Python. (even though the method is
+  // ExportFunctionDefinitionToInterpreter, a class will actually be
+  // exported) (TODO: rename that method to ExportDefinitionToInterpreter)
   if (!ExportFunctionDefinitionToInterpreter(auto_generated_class).Success())
     return false;
 
@@ -1583,11 +1569,11 @@
   return StructuredData::ArraySP();
 }
 
-// GetPythonValueFormatString provides a system independent type safe way to
-// convert a variable's type into a python value format. Python value formats
-// are defined in terms of builtin C types and could change from system to
-// as the underlying typedef for uint* types, size_t, off_t and other values
-// change.
+// GetPythonValueFormatString provides a system independent type safe way
+// to convert a variable's type into a python value format. Python value
+// formats are defined in terms of builtin C types and could change from
+// system to as the underlying typedef for uint* types, size_t, off_t and
+// other values change.
 
 template <typename T> const char *GetPythonValueFormatString(T t);
 template <> const char *GetPythonValueFormatString(char *) { return "s"; }
@@ -2043,9 +2029,9 @@
   Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock,
                 ScriptInterpreterPython::Locker::FreeAcquiredLock);
 
-  // This may be called as part of Py_Finalize.  In that case the modules are
-  // destroyed in random
-  // order and we can't guarantee that we can access these.
+  // This may be called as part of Py_Finalize.  In that case the modules
+  // are destroyed in random order and we can't guarantee that we can
+  // access these.
   if (Py_IsInitialized())
     PyRun_SimpleString("lldb.debugger = None; lldb.target = None; lldb.process "
                        "= None; lldb.thread = None; lldb.frame = None");
@@ -2583,8 +2569,9 @@
     if (ec || st.type() == fs::file_type::status_error ||
         st.type() == fs::file_type::type_unknown ||
         st.type() == fs::file_type::file_not_found) {
-      // if not a valid file of any sort, check if it might be a filename still
-      // dot can't be used but / and \ can, and if either is found, reject
+      // if not a valid file of any sort, check if it might be a filename
+      // still dot can't be used but / and \ can, and if either is found,
+      // reject
       if (strchr(pathname, '\\') || strchr(pathname, '/')) {
         error.SetErrorString("invalid pathname");
         return false;
@@ -2629,9 +2616,9 @@
     command_stream.Clear();
     command_stream.Printf("sys.modules.__contains__('%s')", basename.c_str());
     bool does_contain = false;
-    // this call will succeed if the module was ever imported in any Debugger in
-    // the lifetime of the process
-    // in which this LLDB framework is living
+    // this call will succeed if the module was ever imported in any
+    // Debugger in the lifetime of the process in which this LLDB
+    // framework is living
     bool was_imported_globally =
         (ExecuteOneLineWithReturn(
              command_stream.GetData(),
@@ -2705,8 +2692,8 @@
 
   llvm::StringRef word_sr(word);
 
-  // filter out a few characters that would just confuse us
-  // and that are clearly not keyword material anyway
+  // filter out a few characters that would just confuse us and that are
+  // clearly not keyword material anyway
   if (word_sr.find_first_of("'\"") != llvm::StringRef::npos)
     return false;
 
@@ -2834,9 +2821,9 @@
   return ret_val;
 }
 
-// in Python, a special attribute __doc__ contains the docstring
-// for an object (function, method, class, ...) if any is defined
-// Otherwise, the attribute's value is None
+// in Python, a special attribute __doc__ contains the docstring for an
+// object (function, method, class, ...) if any is defined Otherwise, the
+// attribute's value is None
 bool ScriptInterpreterPython::GetDocumentationForItem(const char *item,
                                                       std::string &dest) {
   dest.clear();
@@ -2846,7 +2833,8 @@
   command += ".__doc__";
 
   char *result_ptr = nullptr; // Python is going to point this to valid data if
-                              // ExecuteOneLineWithReturn returns successfully
+                              // ExecuteOneLineWithReturn returns
+                              // successfully
 
   if (ExecuteOneLineWithReturn(
           command.c_str(), ScriptInterpreter::eScriptReturnTypeCharStrOrNone,
@@ -3105,29 +3093,26 @@
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
-  // RAII-based initialization which correctly handles multiple-initialization,
-  // version-
-  // specific differences among Python 2 and Python 3, and saving and restoring
-  // various
-  // other pieces of state that can get mucked with during initialization.
+  // RAII-based initialization which correctly handles multiple-
+  // initialization, version- specific differences among Python 2 and
+  // Python 3, and saving and restoring various other pieces of state that
+  // can get mucked with during initialization.
   InitializePythonRAII initialize_guard;
 
   if (g_swig_init_callback)
     g_swig_init_callback();
 
-  // Update the path python uses to search for modules to include the current
-  // directory.
+  // Update the path python uses to search for modules to include the
+  // current directory.
 
   PyRun_SimpleString("import sys");
   AddToSysPath(AddLocation::End, ".");
 
   FileSpec file_spec;
-  // Don't denormalize paths when calling file_spec.GetPath().  On platforms
-  // that use
-  // a backslash as the path separator, this will result in executing python
-  // code containing
-  // paths with unescaped backslashes.  But Python also accepts forward slashes,
-  // so to make
+  // Don't denormalize paths when calling file_spec.GetPath().  On
+  // platforms that use a backslash as the path separator, this will
+  // result in executing python code containing paths with unescaped
+  // backslashes.  But Python also accepts forward slashes, so to make
   // life easier we just use that.
   if (HostInfo::GetLLDBPath(ePathTypePythonDir, file_spec))
     AddToSysPath(AddLocation::Beginning, file_spec.GetPath(false));
Index: source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp
===================================================================
--- source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp
+++ source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp
@@ -187,8 +187,8 @@
 
     // Consider impelmenting this action as it would be cheaper to filter.
     // "message" requires always formatting the message, which is a waste
-    // of cycles if it ends up being rejected.
-    // "format",      // format string used to format message text
+    // of cycles if it ends up being rejected. "format",      // format
+    // string used to format message text
 };
 
 static const ConstString &GetDarwinLogTypeName() {
@@ -240,10 +240,9 @@
     dict_p->AddBooleanItem("accept", m_accept);
 
     // Indicate which attribute of the message this filter references.
-    // This can drop into the rule-specific DoSerialization if we get
-    // to the point where not all FilterRule derived classes work on
-    // an attribute.  (e.g. logical and/or and other compound
-    // operations).
+    // This can drop into the rule-specific DoSerialization if we get to
+    // the point where not all FilterRule derived classes work on an
+    // attribute.  (e.g. logical and/or and other compound operations).
     dict_p->AddStringItem("attribute", s_filter_attributes[m_attribute_index]);
 
     // Indicate the type of the rule.
@@ -420,10 +419,10 @@
      "Specifies info-level log messages should be included."},
     {LLDB_OPT_SET_ALL, false, "filter", 'f', OptionParser::eRequiredArgument,
      nullptr, nullptr, 0, eArgRawInput,
-     // There doesn't appear to be a great way for me to have these
-     // multi-line, formatted tables in help.  This looks mostly right
-     // but there are extra linefeeds added at seemingly random spots,
-     // and indentation isn't handled properly on those lines.
+     // There doesn't appear to be a great way for me to have these multi-
+     // line, formatted tables in help.  This looks mostly right but there
+     // are extra linefeeds added at seemingly random spots, and
+     // indentation isn't handled properly on those lines.
      "Appends a filter rule to the log message filter chain.  Multiple "
      "rules may be added by specifying this option multiple times, "
      "once per filter rule.  Filter rules are processed in the order "
@@ -786,12 +785,11 @@
     if (!source_name)
       return;
 
-    // Check if we're *not* using strict sources.  If not,
-    // then the user is going to get debug-level info
-    // anyways, probably not what they're expecting.
-    // Unfortunately we can only fix this by adding an
-    // env var, which would have had to have happened
-    // already.  Thus, a warning is the best we can do here.
+    // Check if we're *not* using strict sources.  If not, then the user
+    // is going to get debug-level info anyways, probably not what they're
+    // expecting. Unfortunately we can only fix this by adding an env var,
+    // which would have had to have happened already.  Thus, a warning is
+    // the best we can do here.
     StreamString stream;
     stream.Printf("darwin-log source settings specify to exclude "
                   "%s messages, but setting "
@@ -805,13 +803,12 @@
   }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    // First off, set the global sticky state of enable/disable
-    // based on this command execution.
+    // First off, set the global sticky state of enable/disable based on
+    // this command execution.
     s_is_explicitly_enabled = m_enable;
 
-    // Next, if this is an enable, save off the option data.
-    // We will need it later if a process hasn't been launched or
-    // attached yet.
+    // Next, if this is an enable, save off the option data. We will need
+    // it later if a process hasn't been launched or attached yet.
     if (m_enable) {
       // Save off enabled configuration so we can apply these parsed
       // options the next time an attach or launch occurs.
@@ -820,9 +817,8 @@
       SetGlobalEnableOptions(debugger_sp, m_options_sp);
     }
 
-    // Now check if we have a running process.  If so, we should
-    // instruct the process monitor to enable/disable DarwinLog support
-    // now.
+    // Now check if we have a running process.  If so, we should instruct
+    // the process monitor to enable/disable DarwinLog support now.
     Target *target = GetSelectedOrDummyTarget();
     if (!target) {
       // No target, so there is nothing more to do right now.
@@ -833,14 +829,13 @@
     // Grab the active process.
     auto process_sp = target->GetProcessSP();
     if (!process_sp) {
-      // No active process, so there is nothing more to do right
-      // now.
+      // No active process, so there is nothing more to do right now.
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
       return true;
     }
 
-    // If the process is no longer alive, we can't do this now.
-    // We'll catch it the next time the process is started up.
+    // If the process is no longer alive, we can't do this now. We'll
+    // catch it the next time the process is started up.
     if (!process_sp->IsAlive()) {
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
       return true;
@@ -859,19 +854,18 @@
         *static_cast<StructuredDataDarwinLog *>(plugin_sp.get());
 
     if (m_enable) {
-      // Hook up the breakpoint for the process that detects when
-      // libtrace has been sufficiently initialized to really start
-      // the os_log stream.  This is insurance to assure us that
-      // logging is really enabled.  Requesting that logging be
-      // enabled for a process before libtrace is initialized
-      // results in a scenario where no errors occur, but no logging
-      // is captured, either.  This step is to eliminate that
-      // possibility.
+      // Hook up the breakpoint for the process that detects when libtrace
+      // has been sufficiently initialized to really start the os_log
+      // stream.  This is insurance to assure us that logging is really
+      // enabled.  Requesting that logging be enabled for a process before
+      // libtrace is initialized results in a scenario where no errors
+      // occur, but no logging is captured, either.  This step is to
+      // eliminate that possibility.
       plugin.AddInitCompletionHook(*process_sp.get());
     }
 
-    // Send configuration to the feature by way of the process.
-    // Construct the options we will use.
+    // Send configuration to the feature by way of the process. Construct
+    // the options we will use.
     auto config_sp = m_options_sp->BuildConfigurationData(m_enable);
     const Status error =
         process_sp->ConfigureStructuredData(GetDarwinLogTypeName(), config_sp);
@@ -884,8 +878,8 @@
       plugin.SetEnabled(false);
     } else {
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
-      // Our configuration succeeeded, so we're enabled/disabled
-      // per whichever one this command is setup to do.
+      // Our configuration succeeeded, so we're enabled/disabled per
+      // whichever one this command is setup to do.
       plugin.SetEnabled(m_enable);
     }
     return result.Succeeded();
@@ -916,8 +910,8 @@
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     auto &stream = result.GetOutputStream();
 
-    // Figure out if we've got a process.  If so, we can tell if
-    // DarwinLog is available for that process.
+    // Figure out if we've got a process.  If so, we can tell if DarwinLog
+    // is available for that process.
     Target *target = GetSelectedOrDummyTarget();
     auto process_sp = target ? target->GetProcessSP() : ProcessSP();
     if (!target || !process_sp) {
@@ -1019,9 +1013,9 @@
   // We are abusing the options data model here so that we can parse
   // options without requiring the Debugger instance.
 
-  // We have an empty execution context at this point.  We only want
-  // to parse options, and we don't need any context to do this here.
-  // In fact, we want to be able to parse the enable options before having
+  // We have an empty execution context at this point.  We only want to
+  // parse options, and we don't need any context to do this here. In
+  // fact, we want to be able to parse the enable options before having
   // any context.
   ExecutionContext exe_ctx;
 
@@ -1172,9 +1166,9 @@
     return;
   }
 
-  // Broadcast the structured data event if we have that enabled.
-  // This is the way that the outside world (all clients) get access
-  // to this data.  This plugin sets policy as to whether we do that.
+  // Broadcast the structured data event if we have that enabled. This is
+  // the way that the outside world (all clients) get access to this data.
+  // This plugin sets policy as to whether we do that.
   DebuggerSP debugger_sp = process.GetTarget().GetDebugger().shared_from_this();
   auto options_sp = GetGlobalEnableOptions(debugger_sp);
   if (options_sp && options_sp->GetBroadcastEvents()) {
@@ -1261,8 +1255,8 @@
           return false;
         }
 
-        // If we haven't already grabbed the first timestamp
-        // value, do that now.
+        // If we haven't already grabbed the first timestamp value, do
+        // that now.
         if (!m_recorded_first_timestamp) {
           uint64_t timestamp = 0;
           if (event->GetValueForKeyAsInteger("timestamp", timestamp)) {
@@ -1321,9 +1315,9 @@
     }
   }
 
-  // The logging support module name, specifies the name of
-  // the image name that must be loaded into the debugged process before
-  // we can try to enable logging.
+  // The logging support module name, specifies the name of the image name
+  // that must be loaded into the debugged process before we can try to
+  // enable logging.
   const char *logging_module_cstr =
       GetGlobalProperties()->GetLoggingModuleName();
   if (!logging_module_cstr || (logging_module_cstr[0] == 0)) {
@@ -1363,8 +1357,8 @@
     return;
   }
 
-  // Time to enqueue the breakpoint so we can wait for logging support
-  // to be initialized before we try to tap the libtrace stream.
+  // Time to enqueue the breakpoint so we can wait for logging support to
+  // be initialized before we try to tap the libtrace stream.
   AddInitCompletionHook(process);
   if (log)
     log->Printf("StructuredDataDarwinLog::%s post-init hook breakpoint "
@@ -1372,13 +1366,13 @@
                 __FUNCTION__, logging_module_name.AsCString(),
                 process.GetUniqueID());
 
-  // We need to try the enable here as well, which will succeed
-  // in the event that we're attaching to (rather than launching) the
-  // process and the process is already past initialization time.  In that
-  // case, the completion breakpoint will never get hit and therefore won't
-  // start that way.  It doesn't hurt much beyond a bit of bandwidth
-  // if we end up doing this twice.  It hurts much more if we don't get
-  // the logging enabled when the user expects it.
+  // We need to try the enable here as well, which will succeed in the
+  // event that we're attaching to (rather than launching) the process and
+  // the process is already past initialization time.  In that case, the
+  // completion breakpoint will never get hit and therefore won't start
+  // that way.  It doesn't hurt much beyond a bit of bandwidth if we end
+  // up doing this twice.  It hurts much more if we don't get the logging
+  // enabled when the user expects it.
   EnableNow();
 }
 
@@ -1415,8 +1409,7 @@
 
 StructuredDataPluginSP
 StructuredDataDarwinLog::CreateInstance(Process &process) {
-  // Currently only Apple targets support the os_log/os_activity
-  // protocol.
+  // Currently only Apple targets support the os_log/os_activity protocol.
   if (process.GetTarget().GetArchitecture().GetTriple().getVendor() ==
       llvm::Triple::VendorType::Apple) {
     auto process_wp = ProcessWP(process.shared_from_this());
@@ -1436,8 +1429,7 @@
   auto parent_command =
       interpreter.GetCommandObjectForCommand(parent_command_text);
   if (!parent_command) {
-    // Ut oh, parent failed to create parent command.
-    // TODO log
+    // Ut oh, parent failed to create parent command. TODO log
     return;
   }
 
@@ -1471,16 +1463,16 @@
   // Darwin os_log() support automatically adds debug-level and info-level
   // messages when a debugger is attached to a process.  However, with
   // integrated suppport for debugging built into the command-line LLDB,
-  // the user may specifically set to *not* include debug-level and info-level
-  // content.  When the user is using the integrated log support, we want
-  // to put the kabosh on that automatic adding of info and debug level.
-  // This is done by adding an environment variable to the process on launch.
-  // (This also means it is not possible to suppress this behavior if
-  // attaching to an already-running app).
-  // Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
-
-  // If the target architecture is not one that supports DarwinLog, we have
-  // nothing to do here.
+  // the user may specifically set to *not* include debug-level and info-
+  // level content.  When the user is using the integrated log support, we
+  // want to put the kabosh on that automatic adding of info and debug
+  // level. This is done by adding an environment variable to the process
+  // on launch. (This also means it is not possible to suppress this
+  // behavior if attaching to an already-running app). Log
+  // *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
+
+  // If the target architecture is not one that supports DarwinLog, we
+  // have nothing to do here.
   auto &triple = target ? target->GetArchitecture().GetTriple()
                         : launch_info.GetArchitecture().GetTriple();
   if (triple.getVendor() != llvm::Triple::Apple) {
@@ -1499,8 +1491,8 @@
   // enable-on-startup set up, but we haven't yet attempted to run the
   // enable command.
   if (!target) {
-    // We really can't do this without a target.  We need to be able
-    // to get to the debugger to get the proper options to do this right.
+    // We really can't do this without a target.  We need to be able to
+    // get to the debugger to get the proper options to do this right.
     // TODO log.
     error.SetErrorString("requires a target to auto-enable DarwinLog.");
     return error;
@@ -1520,12 +1512,13 @@
 
   if (!options_sp->GetEchoToStdErr()) {
     // The user doesn't want to see os_log/NSLog messages echo to stderr.
-    // That mechanism is entirely separate from the DarwinLog support.
-    // By default we don't want to get it via stderr, because that would
-    // be in duplicate of the explicit log support here.
+    // That mechanism is entirely separate from the DarwinLog support. By
+    // default we don't want to get it via stderr, because that would be
+    // in duplicate of the explicit log support here.
 
-    // Here we need to strip out any OS_ACTIVITY_DT_MODE setting to prevent
-    // echoing of os_log()/NSLog() to stderr in the target program.
+    // Here we need to strip out any OS_ACTIVITY_DT_MODE setting to
+    // prevent echoing of os_log()/NSLog() to stderr in the target
+    // program.
     launch_info.GetEnvironment().erase("OS_ACTIVITY_DT_MODE");
 
     // We will also set the env var that tells any downstream launcher
@@ -1551,10 +1544,10 @@
 bool StructuredDataDarwinLog::InitCompletionHookCallback(
     void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id,
     lldb::user_id_t break_loc_id) {
-  // We hit the init function.  We now want to enqueue our new thread plan,
-  // which will in turn enqueue a StepOut thread plan. When the StepOut
-  // finishes and control returns to our new thread plan, that is the time
-  // when we can execute our logic to enable the logging support.
+  // We hit the init function.  We now want to enqueue our new thread
+  // plan, which will in turn enqueue a StepOut thread plan. When the
+  // StepOut finishes and control returns to our new thread plan, that is
+  // the time when we can execute our logic to enable the logging support.
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
   if (log)
@@ -1613,8 +1606,8 @@
                         process_uid);
           return;
         }
-        // Make sure we only call it once, just in case the
-        // thread plan hits the breakpoint twice.
+        // Make sure we only call it once, just in case the thread plan
+        // hits the breakpoint twice.
         if (!called_enable_method) {
           if (log)
             log->Printf("StructuredDataDarwinLog::post-init callback: "
@@ -1624,8 +1617,8 @@
               ->EnableNow();
           called_enable_method = true;
         } else {
-          // Our breakpoint was hit more than once.  Unexpected but
-          // no harm done.  Log it.
+          // Our breakpoint was hit more than once.  Unexpected but no
+          // harm done.  Log it.
           if (log)
             log->Printf("StructuredDataDarwinLog::post-init callback: "
                         "skipping EnableNow(), already called by "
@@ -1682,8 +1675,8 @@
     m_added_breakpoint = true;
   }
 
-  // Set a breakpoint for the process that will kick in when libtrace
-  // has finished its initialization.
+  // Set a breakpoint for the process that will kick in when libtrace has
+  // finished its initialization.
   Target &target = process.GetTarget();
 
   // Build up the module list.
@@ -1831,8 +1824,8 @@
   // Check the type of the event.
   ConstString event_type;
   if (!event.GetValueForKeyAsString("type", event_type)) {
-    // Hmm, we expected to get events that describe
-    // what they are.  Continue anyway.
+    // Hmm, we expected to get events that describe what they are.
+    // Continue anyway.
     return 0;
   }
 
@@ -1882,8 +1875,8 @@
 
   // If we have configuration data, we can directly enable it now.
   // Otherwise, we need to run through the command interpreter to parse
-  // the auto-run options (which is the only way we get here without having
-  // already-parsed configuration data).
+  // the auto-run options (which is the only way we get here without
+  // having already-parsed configuration data).
   DebuggerSP debugger_sp =
       process_sp->GetTarget().GetDebugger().shared_from_this();
   if (!debugger_sp) {
Index: source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp
@@ -106,9 +106,9 @@
 
   bool NextBitfieldOffsetIsValid(const uint64_t next_bit_offset) const {
     if (IsValid()) {
-      // This bitfield info is valid, so any subsequent bitfields
-      // must not overlap and must be at a higher bit offset than
-      // any previous bitfield + size.
+      // This bitfield info is valid, so any subsequent bitfields must not
+      // overlap and must be at a higher bit offset than any previous
+      // bitfield + size.
       return (bit_size + bit_offset) <= next_bit_offset;
     } else {
       // If the this BitfieldInfo is not valid, then any offset isOK
@@ -168,9 +168,8 @@
   if (num_dwo_types != 1)
     return TypeSP();
 
-  // We found a real definition for this type in the Clang module, so
-  // lets use it and cache the fact that we found a complete type for
-  // this die.
+  // We found a real definition for this type in the Clang module, so lets
+  // use it and cache the fact that we found a complete type for this die.
   TypeSP dwo_type_sp = dwo_types.GetTypeAtIndex(0);
   if (!dwo_type_sp)
     return TypeSP();
@@ -211,8 +210,8 @@
   if (!tag_decl_ctx)
     return;
 
-  // If this type was not imported from an external AST, there's
-  // nothing to do.
+  // If this type was not imported from an external AST, there's nothing
+  // to do.
   CompilerType type = ClangASTContext::GetTypeForDecl(tag_decl_ctx);
   if (!type || !ast_importer.CanImport(type))
     return;
@@ -223,8 +222,8 @@
         "Unable to complete the Decl context for DIE '%s' at offset "
         "0x%8.8x.\nPlease file a bug report.",
         type_name_cstr ? type_name_cstr : "", die.GetOffset());
-    // We need to make the type look complete otherwise, we
-    // might crash in Clang when adding children.
+    // We need to make the type look complete otherwise, we might crash in
+    // Clang when adding children.
     if (ClangASTContext::StartTagDeclarationDefinition(type))
       ClangASTContext::CompleteTagDeclarationDefinition(type);
   }
@@ -311,9 +310,8 @@
               case DW_AT_name:
 
                 type_name_cstr = form_value.AsCString();
-                // Work around a bug in llvm-gcc where they give a name to a
-                // reference type which doesn't
-                // include the "&"...
+                // Work around a bug in llvm-gcc where they give a name to
+                // a reference type which doesn't include the "&"...
                 if (tag == DW_TAG_reference_type) {
                   if (strchr(type_name_cstr, '&') == NULL)
                     type_name_cstr = NULL;
@@ -339,32 +337,35 @@
         }
 
         if (tag == DW_TAG_typedef && encoding_uid.IsValid()) {
-          // Try to parse a typedef from the DWO file first as modules
-          // can contain typedef'ed structures that have no names like:
+          // Try to parse a typedef from the DWO file first as modules can
+          // contain typedef'ed structures that have no names like:
           //
           //  typedef struct { int a; } Foo;
           //
           // In this case we will have a structure with no name and a
           // typedef named "Foo" that points to this unnamed structure.
-          // The name in the typedef is the only identifier for the struct,
-          // so always try to get typedefs from DWO files if possible.
+          // The name in the typedef is the only identifier for the
+          // struct, so always try to get typedefs from DWO files if
+          // possible.
           //
-          // The type_sp returned will be empty if the typedef doesn't exist
-          // in a DWO file, so it is cheap to call this function just to check.
+          // The type_sp returned will be empty if the typedef doesn't
+          // exist in a DWO file, so it is cheap to call this function
+          // just to check.
           //
-          // If we don't do this we end up creating a TypeSP that says this
-          // is a typedef to type 0x123 (the DW_AT_type value would be 0x123
-          // in the DW_TAG_typedef), and this is the unnamed structure type.
-          // We will have a hard time tracking down an unnammed structure
-          // type in the module DWO file, so we make sure we don't get into
-          // this situation by always resolving typedefs from the DWO file.
+          // If we don't do this we end up creating a TypeSP that says
+          // this is a typedef to type 0x123 (the DW_AT_type value would
+          // be 0x123 in the DW_TAG_typedef), and this is the unnamed
+          // structure type. We will have a hard time tracking down an
+          // unnammed structure type in the module DWO file, so we make
+          // sure we don't get into this situation by always resolving
+          // typedefs from the DWO file.
           const DWARFDIE encoding_die = dwarf->GetDIE(DIERef(encoding_uid));
 
           // First make sure that the die that this is typedef'ed to _is_
-          // just a declaration (DW_AT_declaration == 1), not a full definition
-          // since template types can't be represented in modules since only
-          // concrete instances of templates are ever emitted and modules
-          // won't contain those
+          // just a declaration (DW_AT_declaration == 1), not a full
+          // definition since template types can't be represented in
+          // modules since only concrete instances of templates are ever
+          // emitted and modules won't contain those
           if (encoding_die &&
               encoding_die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0) ==
                   1) {
@@ -389,8 +390,8 @@
             clang_type = m_ast.GetBasicType(eBasicTypeNullPtr);
             break;
           }
-          // Fall through to base type below in case we can handle the type
-          // there...
+          // Fall through to base type below in case we can handle the
+          // type there...
           LLVM_FALLTHROUGH;
 
         case DW_TAG_base_type:
@@ -430,8 +431,8 @@
             DWARFDIE target_die = die.GetReferencedDIE(DW_AT_type);
 
             if (target_die.GetAttributeValueAsUnsigned(DW_AT_APPLE_block, 0)) {
-              // Blocks have a __FuncPtr inside them which is a pointer to a
-              // function of the proper type.
+              // Blocks have a __FuncPtr inside them which is a pointer to
+              // a function of the proper type.
 
               for (DWARFDIE child_die = target_die.GetFirstChild();
                    child_die.IsValid(); child_die = child_die.GetSibling()) {
@@ -507,8 +508,8 @@
               }
             } else if (encoding_data_type == Type::eEncodingIsPointerUID &&
                        encoding_uid.IsValid()) {
-              // Clang sometimes erroneously emits id as objc_object*.  In that
-              // case we fix up the type to "id".
+              // Clang sometimes erroneously emits id as objc_object*.  In
+              // that case we fix up the type to "id".
 
               const DWARFDIE encoding_die = dwarf->GetDIE(DIERef(encoding_uid));
 
@@ -562,11 +563,10 @@
               switch (attr) {
               case DW_AT_decl_file:
                 if (die.GetCU()->DW_AT_decl_file_attributes_are_invalid()) {
-                  // llvm-gcc outputs invalid DW_AT_decl_file attributes that
-                  // always
-                  // point to the compile unit file, so we clear this invalid
-                  // value
-                  // so that we can still unique types efficiently.
+                  // llvm-gcc outputs invalid DW_AT_decl_file attributes
+                  // that always point to the compile unit file, so we
+                  // clear this invalid value so that we can still unique
+                  // types efficiently.
                   decl.SetFile(FileSpec("<invalid>", false));
                 } else
                   decl.SetFile(
@@ -625,10 +625,10 @@
           }
         }
 
-        // UniqueDWARFASTType is large, so don't create a local variables on the
-        // stack, put it on the heap. This function is often called recursively
-        // and clang isn't good and sharing the stack space for variables in
-        // different blocks.
+        // UniqueDWARFASTType is large, so don't create a local variables
+        // on the stack, put it on the heap. This function is often called
+        // recursively and clang isn't good and sharing the stack space
+        // for variables in different blocks.
         std::unique_ptr<UniqueDWARFASTType> unique_ast_entry_ap(
             new UniqueDWARFASTType());
 
@@ -638,11 +638,9 @@
         if (type_name_const_str) {
           LanguageType die_language = die.GetLanguage();
           if (Language::LanguageIsCPlusPlus(die_language)) {
-            // For C++, we rely solely upon the one definition rule that says
-            // only
-            // one thing can exist at a given decl context. We ignore the file
-            // and
-            // line that things are declared on.
+            // For C++, we rely solely upon the one definition rule that
+            // says only one thing can exist at a given decl context. We
+            // ignore the file and line that things are declared on.
             std::string qualified_name;
             if (die.GetQualifiedName(qualified_name))
               unique_typename = ConstString(qualified_name);
@@ -679,17 +677,16 @@
         if (byte_size_valid && byte_size == 0 && type_name_cstr &&
             die.HasChildren() == false &&
             sc.comp_unit->GetLanguage() == eLanguageTypeObjC) {
-          // Work around an issue with clang at the moment where
-          // forward declarations for objective C classes are emitted
-          // as:
+          // Work around an issue with clang at the moment where forward
+          // declarations for objective C classes are emitted as:
           //  DW_TAG_structure_type [2]
           //  DW_AT_name( "ForwardObjcClass" )
           //  DW_AT_byte_size( 0x00 )
           //  DW_AT_decl_file( "..." )
           //  DW_AT_decl_line( 1 )
           //
-          // Note that there is no DW_AT_declaration and there are
-          // no children, and the byte size is zero.
+          // Note that there is no DW_AT_declaration and there are no
+          // children, and the byte size is zero.
           is_forward_declaration = true;
         }
 
@@ -698,10 +695,10 @@
           if (!is_complete_objc_class &&
               die.Supports_DW_AT_APPLE_objc_complete_type()) {
             // We have a valid eSymbolTypeObjCClass class symbol whose
-            // name matches the current objective C class that we
-            // are trying to find and this DIE isn't the complete
-            // definition (we checked is_complete_objc_class above and
-            // know it is false), so the real definition is in here somewhere
+            // name matches the current objective C class that we are
+            // trying to find and this DIE isn't the complete definition
+            // (we checked is_complete_objc_class above and know it is
+            // false), so the real definition is in here somewhere
             type_sp = dwarf->FindCompleteObjCDefinitionTypeForDIE(
                 die, type_name_const_str, true);
 
@@ -709,9 +706,8 @@
               SymbolFileDWARFDebugMap *debug_map_symfile =
                   dwarf->GetDebugMapSymfile();
               if (debug_map_symfile) {
-                // We weren't able to find a full declaration in
-                // this DWARF, see if we have a declaration anywhere
-                // else...
+                // We weren't able to find a full declaration in this
+                // DWARF, see if we have a declaration anywhere else...
                 type_sp =
                     debug_map_symfile->FindCompleteObjCDefinitionTypeForDIE(
                         die, type_name_const_str, true);
@@ -728,9 +724,9 @@
                     type_sp->GetID());
               }
 
-              // We found a real definition for this type elsewhere
-              // so lets use it and cache the fact that we found
-              // a complete type for this die
+              // We found a real definition for this type elsewhere so
+              // lets use it and cache the fact that we found a complete
+              // type for this die
               dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
               return type_sp;
             }
@@ -738,11 +734,11 @@
         }
 
         if (is_forward_declaration) {
-          // We have a forward declaration to a type and we need
-          // to try and find a full declaration. We look in the
-          // current type index just in case we have a forward
-          // declaration followed by an actual declarations in the
-          // DWARF. If this fails, we need to look elsewhere...
+          // We have a forward declaration to a type and we need to try
+          // and find a full declaration. We look in the current type
+          // index just in case we have a forward declaration followed by
+          // an actual declarations in the DWARF. If this fails, we need
+          // to look elsewhere...
           if (log) {
             dwarf->GetObjectFile()->GetModule()->LogMessage(
                 log, "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is a "
@@ -751,8 +747,8 @@
                 DW_TAG_value_to_name(tag), type_name_cstr);
           }
 
-          // See if the type comes from a DWO module and if so, track down that
-          // type.
+          // See if the type comes from a DWO module and if so, track down
+          // that type.
           type_sp = ParseTypeFromDWO(die, log);
           if (type_sp)
             return type_sp;
@@ -768,9 +764,8 @@
             SymbolFileDWARFDebugMap *debug_map_symfile =
                 dwarf->GetDebugMapSymfile();
             if (debug_map_symfile) {
-              // We weren't able to find a full declaration in
-              // this DWARF, see if we have a declaration anywhere
-              // else...
+              // We weren't able to find a full declaration in this DWARF,
+              // see if we have a declaration anywhere else...
               type_sp =
                   debug_map_symfile->FindDefinitionTypeForDWARFDeclContext(
                       die_decl_ctx);
@@ -786,9 +781,9 @@
                   DW_TAG_value_to_name(tag), type_name_cstr, type_sp->GetID());
             }
 
-            // We found a real definition for this type elsewhere
-            // so lets use it and cache the fact that we found
-            // a complete type for this die
+            // We found a real definition for this type elsewhere so lets
+            // use it and cache the fact that we found a complete type for
+            // this die
             dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
             clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(
                 dwarf->DebugInfo()->GetDIE(DIERef(type_sp->GetID(), dwarf)));
@@ -806,17 +801,18 @@
               GetClangDeclContextContainingDIE(die, nullptr);
 
           // If your decl context is a record that was imported from
-          // another AST context (in the gmodules case), we need to
-          // make sure the type backing the Decl is complete before
-          // adding children to it. This is not an issue in the
-          // non-gmodules case because the debug info will always contain
-          // a full definition of parent types in that case.
+          // another AST context (in the gmodules case), we need to make
+          // sure the type backing the Decl is complete before adding
+          // children to it. This is not an issue in the non-gmodules case
+          // because the debug info will always contain a full definition
+          // of parent types in that case.
           CompleteExternalTagDeclType(GetClangASTImporter(), decl_ctx, die,
                                       type_name_cstr);
 
           if (accessibility == eAccessNone && decl_ctx) {
-            // Check the decl context that contains this class/struct/union.
-            // If it is a class we must give it an accessibility.
+            // Check the decl context that contains this
+            // class/struct/union. If it is a class we must give it an
+            // accessibility.
             const clang::Decl::Kind containing_decl_kind =
                 decl_ctx->getDeclKind();
             if (DeclKindIsCXXClass(containing_decl_kind))
@@ -868,8 +864,8 @@
         }
         
         // Store a forward declaration to this class type in case any
-        // parameters in any class methods need it for the clang
-        // types for function prototypes.
+        // parameters in any class methods need it for the clang types for
+        // function prototypes.
         LinkDeclContextToDIE(m_ast.GetDeclContextForType(clang_type), die);
         type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str,
                                byte_size, NULL, LLDB_INVALID_UID,
@@ -878,9 +874,9 @@
 
         type_sp->SetIsCompleteObjCClass(is_complete_objc_class);
 
-        // Add our type to the unique type map so we don't
-        // end up creating many copies of the same type over
-        // and over in the ASTContext for our module
+        // Add our type to the unique type map so we don't end up creating
+        // many copies of the same type over and over in the ASTContext
+        // for our module
         unique_ast_entry_ap->m_type_sp = type_sp;
         unique_ast_entry_ap->m_die = die;
         unique_ast_entry_ap->m_declaration = unique_decl;
@@ -889,11 +885,10 @@
                                                  *unique_ast_entry_ap);
 
         if (is_forward_declaration && die.HasChildren()) {
-          // Check to see if the DIE actually has a definition, some version of
-          // GCC will
-          // emit DIEs with DW_AT_declaration set to true, but yet still have
-          // subprogram,
-          // members, or inheritance, so we can't trust it
+          // Check to see if the DIE actually has a definition, some
+          // version of GCC will emit DIEs with DW_AT_declaration set to
+          // true, but yet still have subprogram, members, or inheritance,
+          // so we can't trust it
           DWARFDIE child_die = die.GetFirstChild();
           while (child_die) {
             switch (child_die.Tag()) {
@@ -917,10 +912,10 @@
         }
 
         if (!is_forward_declaration) {
-          // Always start the definition for a class type so that
-          // if the class has child classes or types that require
-          // the class to be created for use as their decl contexts
-          // the class will be ready to accept these child definitions.
+          // Always start the definition for a class type so that if the
+          // class has child classes or types that require the class to be
+          // created for use as their decl contexts the class will be
+          // ready to accept these child definitions.
           if (die.HasChildren() == false) {
             // No children for this struct/union/class, lets finish it
             if (ClangASTContext::StartTagDeclarationDefinition(clang_type)) {
@@ -945,32 +940,30 @@
             }
           } else if (clang_type_was_created) {
             // Start the definition if the class is not objective C since
-            // the underlying decls respond to isCompleteDefinition(). Objective
-            // C decls don't respond to isCompleteDefinition() so we can't
-            // start the declaration definition right away. For C++
-            // class/union/structs
-            // we want to start the definition in case the class is needed as
-            // the
-            // declaration context for a contained class or type without the
-            // need
-            // to complete that type..
+            // the underlying decls respond to isCompleteDefinition().
+            // Objective C decls don't respond to isCompleteDefinition()
+            // so we can't start the declaration definition right away.
+            // For C++ class/union/structs we want to start the definition
+            // in case the class is needed as the declaration context for
+            // a contained class or type without the need to complete that
+            // type..
 
             if (class_language != eLanguageTypeObjC &&
                 class_language != eLanguageTypeObjC_plus_plus)
               ClangASTContext::StartTagDeclarationDefinition(clang_type);
 
-            // Leave this as a forward declaration until we need
-            // to know the details of the type. lldb_private::Type
-            // will automatically call the SymbolFile virtual function
-            // "SymbolFileDWARF::CompleteType(Type *)"
-            // When the definition needs to be defined.
+            // Leave this as a forward declaration until we need to know
+            // the details of the type. lldb_private::Type will
+            // automatically call the SymbolFile virtual function
+            // "SymbolFileDWARF::CompleteType(Type *)" When the definition
+            // needs to be defined.
             assert(!dwarf->GetForwardDeclClangTypeToDie().count(
                        ClangUtil::RemoveFastQualifiers(clang_type)
                            .GetOpaqueQualType()) &&
                    "Type already in the forward declaration map!");
-            // Can't assume m_ast.GetSymbolFile() is actually a SymbolFileDWARF,
-            // it can be a
-            // SymbolFileDWARFDebugMap for Apple binaries.
+            // Can't assume m_ast.GetSymbolFile() is actually a
+            // SymbolFileDWARF, it can be a SymbolFileDWARFDebugMap for
+            // Apple binaries.
             dwarf->GetForwardDeclDieToClangType()[die.GetDIE()] =
                 clang_type.GetOpaqueQualType();
             dwarf->GetForwardDeclClangTypeToDie()
@@ -980,11 +973,11 @@
           }
         }
         
-        // If we made a clang type, set the trivial abi if applicable:
-        // We only do this for pass by value - which implies the Trivial ABI.
-        // There isn't a way to assert that something that would normally be
-        // pass by value is pass by reference, so we ignore that attribute if
-        // set.
+        // If we made a clang type, set the trivial abi if applicable: We
+        // only do this for pass by value - which implies the Trivial ABI.
+        // There isn't a way to assert that something that would normally
+        // be pass by value is pass by reference, so we ignore that
+        // attribute if set.
         if (calling_convention == llvm::dwarf::DW_CC_pass_by_value) {
           clang::CXXRecordDecl *record_decl =
                   m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
@@ -1032,7 +1025,8 @@
                 break;
               case DW_AT_accessibility:
                 break; // accessibility =
-                       // DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
+                       // DW_ACCESS_to_AccessType(form_value.Unsigned());
+                       // break;
               case DW_AT_declaration:
                 is_forward_declaration = form_value.Boolean();
                 break;
@@ -1070,9 +1064,8 @@
               SymbolFileDWARFDebugMap *debug_map_symfile =
                   dwarf->GetDebugMapSymfile();
               if (debug_map_symfile) {
-                // We weren't able to find a full declaration in
-                // this DWARF, see if we have a declaration anywhere
-                // else...
+                // We weren't able to find a full declaration in this
+                // DWARF, see if we have a declaration anywhere else...
                 type_sp =
                     debug_map_symfile->FindDefinitionTypeForDWARFDeclContext(
                         die_decl_ctx);
@@ -1089,9 +1082,9 @@
                     type_sp->GetID());
               }
 
-              // We found a real definition for this type elsewhere
-              // so lets use it and cache the fact that we found
-              // a complete type for this die
+              // We found a real definition for this type elsewhere so
+              // lets use it and cache the fact that we found a complete
+              // type for this die
               dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
               clang::DeclContext *defn_decl_ctx =
                   GetCachedClangDeclContextForDIE(dwarf->DebugInfo()->GetDIE(
@@ -1317,8 +1310,8 @@
 
         bool is_cxx_method = DeclKindIsCXXClass(containing_decl_kind);
         // Start off static. This will be set to false in
-        // ParseChildParameters(...)
-        // if we find a "this" parameters as the first parameter
+        // ParseChildParameters(...) if we find a "this" parameters as the
+        // first parameter
         if (is_cxx_method) {
           is_static = true;
         }
@@ -1333,25 +1326,24 @@
 
         bool ignore_containing_context = false;
         // Check for templatized class member functions. If we had any
-        // DW_TAG_template_type_parameter
-        // or DW_TAG_template_value_parameter the DW_TAG_subprogram DIE, then we
-        // can't let this become
-        // a method in a class. Why? Because templatized functions are only
-        // emitted if one of the
-        // templatized methods is used in the current compile unit and we will
-        // end up with classes
-        // that may or may not include these member functions and this means one
-        // class won't match another
-        // class definition and it affects our ability to use a class in the
-        // clang expression parser. So
-        // for the greater good, we currently must not allow any template member
-        // functions in a class definition.
+        // DW_TAG_template_type_parameter or
+        // DW_TAG_template_value_parameter the DW_TAG_subprogram DIE, then
+        // we can't let this become a method in a class. Why? Because
+        // templatized functions are only emitted if one of the
+        // templatized methods is used in the current compile unit and we
+        // will end up with classes that may or may not include these
+        // member functions and this means one class won't match another
+        // class definition and it affects our ability to use a class in
+        // the clang expression parser. So for the greater good, we
+        // currently must not allow any template member functions in a
+        // class definition.
         if (is_cxx_method && has_template_params) {
           ignore_containing_context = true;
           is_cxx_method = false;
         }
 
-        // clang_type will get the function prototype clang type after this call
+        // clang_type will get the function prototype clang type after
+        // this call
         clang_type = m_ast.CreateFunctionType(
             return_clang_type, function_param_types.data(),
             function_param_types.size(), is_variadic, type_quals);
@@ -1378,9 +1370,8 @@
               }
 
               if (class_opaque_type) {
-                // If accessibility isn't set to anything valid, assume public
-                // for
-                // now...
+                // If accessibility isn't set to anything valid, assume
+                // public for now...
                 if (accessibility == eAccessNone)
                   accessibility = eAccessPublic;
 
@@ -1402,9 +1393,8 @@
                 }
               }
             } else if (is_cxx_method) {
-              // Look at the parent of this DIE and see if is is
-              // a class or struct and see if this is actually a
-              // C++ method
+              // Look at the parent of this DIE and see if is is a class
+              // or struct and see if this is actually a C++ method
               Type *class_type = dwarf->ResolveType(decl_ctx_die);
               if (class_type) {
                 bool alternate_defn = false;
@@ -1412,11 +1402,10 @@
                     decl_ctx_die.GetContainingDWOModuleDIE()) {
                   alternate_defn = true;
 
-                  // We uniqued the parent class of this function to another
-                  // class
-                  // so we now need to associate all dies under "decl_ctx_die"
-                  // to
-                  // DIEs in the DIE for "class_type"...
+                  // We uniqued the parent class of this function to
+                  // another class so we now need to associate all dies
+                  // under "decl_ctx_die" to DIEs in the DIE for
+                  // "class_type"...
                   SymbolFileDWARF *class_symfile = NULL;
                   DWARFDIE class_type_die;
 
@@ -1439,13 +1428,10 @@
                     CopyUniqueClassMethodTypes(decl_ctx_die, class_type_die,
                                                class_type, failures);
 
-                    // FIXME do something with these failures that's smarter
-                    // than
-                    // just dropping them on the ground.  Unfortunately classes
-                    // don't
-                    // like having stuff added to them after their definitions
-                    // are
-                    // complete...
+                    // FIXME do something with these failures that's
+                    // smarter than just dropping them on the ground.
+                    // Unfortunately classes don't like having stuff added
+                    // to them after their definitions are complete...
 
                     type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
                     if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) {
@@ -1456,17 +1442,15 @@
                 }
 
                 if (specification_die_form.IsValid()) {
-                  // We have a specification which we are going to base our
-                  // function
-                  // prototype off of, so we need this type to be completed so
-                  // that the
-                  // m_die_to_decl_ctx for the method in the specification has a
-                  // valid
-                  // clang decl context.
+                  // We have a specification which we are going to base
+                  // our function prototype off of, so we need this type
+                  // to be completed so that the m_die_to_decl_ctx for the
+                  // method in the specification has a valid clang decl
+                  // context.
                   class_type->GetForwardCompilerType();
-                  // If we have a specification, then the function type should
-                  // have been
-                  // made with the specification and not with this die.
+                  // If we have a specification, then the function type
+                  // should have been made with the specification and not
+                  // with this die.
                   DWARFDIE spec_die = dwarf->DebugInfo()->GetDIE(
                       DIERef(specification_die_form));
                   clang::DeclContext *spec_clang_decl_ctx =
@@ -1481,13 +1465,11 @@
                   }
                   type_handled = true;
                 } else if (abstract_origin_die_form.IsValid()) {
-                  // We have a specification which we are going to base our
-                  // function
-                  // prototype off of, so we need this type to be completed so
-                  // that the
-                  // m_die_to_decl_ctx for the method in the abstract origin has
-                  // a valid
-                  // clang decl context.
+                  // We have a specification which we are going to base
+                  // our function prototype off of, so we need this type
+                  // to be completed so that the m_die_to_decl_ctx for the
+                  // method in the abstract origin has a valid clang decl
+                  // context.
                   class_type->GetForwardCompilerType();
 
                   DWARFDIE abs_die = dwarf->DebugInfo()->GetDIE(
@@ -1509,17 +1491,16 @@
                   if (ClangASTContext::IsCXXClassType(class_opaque_type)) {
                     if (class_opaque_type.IsBeingDefined() || alternate_defn) {
                       if (!is_static && !die.HasChildren()) {
-                        // We have a C++ member function with no children (this
-                        // pointer!)
-                        // and clang will get mad if we try and make a function
-                        // that isn't
-                        // well formed in the DWARF, so we will just skip it...
+                        // We have a C++ member function with no children
+                        // (this pointer!) and clang will get mad if we
+                        // try and make a function that isn't well formed
+                        // in the DWARF, so we will just skip it...
                         type_handled = true;
                       } else {
                         bool add_method = true;
                         if (alternate_defn) {
-                          // If an alternate definition for the class exists,
-                          // then add the method only if an
+                          // If an alternate definition for the class
+                          // exists, then add the method only if an
                           // equivalent is not already present.
                           clang::CXXRecordDecl *record_decl =
                               m_ast.GetAsCXXRecordDecl(
@@ -1559,10 +1540,9 @@
                                   .c_str());
 
                           const bool is_attr_used = false;
-                          // Neither GCC 4.2 nor clang++ currently set a valid
-                          // accessibility
-                          // in the DWARF for C++ methods... Default to public
-                          // for now...
+                          // Neither GCC 4.2 nor clang++ currently set a
+                          // valid accessibility in the DWARF for C++
+                          // methods... Default to public for now...
                           if (accessibility == eAccessNone)
                             accessibility = eAccessPublic;
 
@@ -1603,39 +1583,35 @@
                       }
                     } else {
                       // We were asked to parse the type for a method in a
-                      // class, yet the
-                      // class hasn't been asked to complete itself through the
-                      // clang::ExternalASTSource protocol, so we need to just
-                      // have the
-                      // class complete itself and do things the right way, then
-                      // our
-                      // DIE should then have an entry in the
-                      // dwarf->GetDIEToType() map. First
-                      // we need to modify the dwarf->GetDIEToType() so it
-                      // doesn't think we are
-                      // trying to parse this DIE anymore...
+                      // class, yet the class hasn't been asked to
+                      // complete itself through the
+                      // clang::ExternalASTSource protocol, so we need to
+                      // just have the class complete itself and do things
+                      // the right way, then our DIE should then have an
+                      // entry in the dwarf->GetDIEToType() map. First we
+                      // need to modify the dwarf->GetDIEToType() so it
+                      // doesn't think we are trying to parse this DIE
+                      // anymore...
                       dwarf->GetDIEToType()[die.GetDIE()] = NULL;
 
-                      // Now we get the full type to force our class type to
-                      // complete itself
-                      // using the clang::ExternalASTSource protocol which will
-                      // parse all
-                      // base classes and all methods (including the method for
-                      // this DIE).
+                      // Now we get the full type to force our class type
+                      // to complete itself using the
+                      // clang::ExternalASTSource protocol which will
+                      // parse all base classes and all methods (including
+                      // the method for this DIE).
                       class_type->GetFullCompilerType();
 
-                      // The type for this DIE should have been filled in the
-                      // function call above
+                      // The type for this DIE should have been filled in
+                      // the function call above
                       type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
                       if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) {
                         type_sp = type_ptr->shared_from_this();
                         break;
                       }
 
-                      // FIXME This is fixing some even uglier behavior but we
-                      // really need to
-                      // uniq the methods of each class as well as the class
-                      // itself.
+                      // FIXME This is fixing some even uglier behavior
+                      // but we really need to uniq the methods of each
+                      // class as well as the class itself.
                       // <rdar://problem/11240464>
                       type_handled = true;
                     }
@@ -1762,7 +1738,8 @@
                 break;
               case DW_AT_accessibility:
                 break; // accessibility =
-                       // DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
+                       // DW_ACCESS_to_AccessType(form_value.Unsigned());
+                       // break;
               case DW_AT_declaration:
                 break; // is_forward_declaration = form_value.Boolean(); break;
               case DW_AT_allocated:
@@ -1820,12 +1797,12 @@
                           : "the source file");
               }
 
-              // We have no choice other than to pretend that the element class
-              // type
-              // is complete. If we don't do this, clang will crash when trying
-              // to layout the class. Since we provide layout assistance, all
-              // ivars in this class and other classes will be fine, this is
-              // the best we can do short of crashing.
+              // We have no choice other than to pretend that the element
+              // class type is complete. If we don't do this, clang will
+              // crash when trying to layout the class. Since we provide
+              // layout assistance, all ivars in this class and other
+              // classes will be fine, this is the best we can do short of
+              // crashing.
               if (ClangASTContext::StartTagDeclarationDefinition(
                       array_element_type)) {
                 ClangASTContext::CompleteTagDeclarationDefinition(
@@ -1938,8 +1915,8 @@
           type_sp->SetSymbolContextScope(symbol_context_scope);
         }
 
-        // We are ready to put this type into the uniqued list up at the module
-        // level
+        // We are ready to put this type into the uniqued list up at the
+        // module level
         type_list->Insert(type_sp);
 
         dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
@@ -2091,7 +2068,8 @@
         else
           template_param_infos.names.push_back(NULL);
 
-        // Get the signed value for any integer or enumeration if available
+        // Get the signed value for any integer or enumeration if
+        // available
         clang_type.IsIntegerOrEnumerationType(is_signed);
 
         if (tag == DW_TAG_template_value_parameter && uval64_valid) {
@@ -2148,10 +2126,11 @@
 }
 
 // Checks whether m1 is an overload of m2 (as opposed to an override).
-// This is called by addOverridesForMethod to distinguish overrides (which share
-// a vtable entry) from overloads (which require distinct entries).
+// This is called by addOverridesForMethod to distinguish overrides (which
+// share a vtable entry) from overloads (which require distinct entries).
 static bool isOverload(clang::CXXMethodDecl *m1, clang::CXXMethodDecl *m2) {
-  // FIXME: This should detect covariant return types, but currently doesn't.
+  // FIXME: This should detect covariant return types, but currently
+  // doesn't.
   lldbassert(&m1->getASTContext() == &m2->getASTContext() &&
              "Methods should have the same AST context");
   clang::ASTContext &context = m1->getASTContext();
@@ -2177,9 +2156,9 @@
                      m2Type->param_type_begin(), compareArgTypes);
 }
 
-// If decl is a virtual method, walk the base classes looking for methods that
-// decl overrides. This table of overridden methods is used by IRGen to determine
-// the vtable layout for decl's parent class.
+// If decl is a virtual method, walk the base classes looking for methods
+// that decl overrides. This table of overridden methods is used by IRGen
+// to determine the vtable layout for decl's parent class.
 static void addOverridesForMethod(clang::CXXMethodDecl *decl) {
   if (!decl->isVirtual())
     return;
@@ -2194,8 +2173,8 @@
 
         clang::DeclarationName name = decl->getDeclName();
 
-        // If this is a destructor, check whether the base class destructor is
-        // virtual.
+        // If this is a destructor, check whether the base class
+        // destructor is virtual.
         if (name.getNameKind() == clang::DeclarationName::CXXDestructorName)
           if (auto *baseDtorDecl = base_record->getDestructor()) {
             if (baseDtorDecl->isVirtual()) {
@@ -2227,8 +2206,8 @@
   }
 }
 
-// If clang_type is a CXXRecordDecl, builds the method override list for each
-// of its virtual methods.
+// If clang_type is a CXXRecordDecl, builds the method override list for
+// each of its virtual methods.
 static void addMethodOverrides(ClangASTContext &ast, CompilerType &clang_type) {
   if (auto *record =
       ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType()))
@@ -2307,8 +2286,8 @@
         LanguageType class_language = eLanguageTypeUnknown;
         if (ClangASTContext::IsObjCObjectOrInterfaceType(clang_type)) {
           class_language = eLanguageTypeObjC;
-          // For objective C we don't start the definition when
-          // the class is created.
+          // For objective C we don't start the definition when the class
+          // is created.
           ClangASTContext::StartTagDeclarationDefinition(clang_type);
         }
 
@@ -2372,27 +2351,27 @@
           }
         }
 
-        // If we have a DW_TAG_structure_type instead of a DW_TAG_class_type we
-        // need to tell the clang type it is actually a class.
+        // If we have a DW_TAG_structure_type instead of a
+        // DW_TAG_class_type we need to tell the clang type it is actually
+        // a class.
         if (class_language != eLanguageTypeObjC) {
           if (is_a_class && tag_decl_kind != clang::TTK_Class)
             m_ast.SetTagTypeKind(ClangUtil::GetQualType(clang_type),
                                  clang::TTK_Class);
         }
 
-        // Since DW_TAG_structure_type gets used for both classes
-        // and structures, we may need to set any DW_TAG_member
-        // fields to have a "private" access if none was specified.
-        // When we parsed the child members we tracked that actual
-        // accessibility value for each DW_TAG_member in the
-        // "member_accessibilities" array. If the value for the
-        // member is zero, then it was set to the "default_accessibility"
-        // which for structs was "public". Below we correct this
-        // by setting any fields to "private" that weren't correctly
-        // set.
+        // Since DW_TAG_structure_type gets used for both classes and
+        // structures, we may need to set any DW_TAG_member fields to have
+        // a "private" access if none was specified. When we parsed the
+        // child members we tracked that actual accessibility value for
+        // each DW_TAG_member in the "member_accessibilities" array. If
+        // the value for the member is zero, then it was set to the
+        // "default_accessibility" which for structs was "public". Below
+        // we correct this by setting any fields to "private" that weren't
+        // correctly set.
         if (is_a_class && !member_accessibilities.empty()) {
-          // This is a class and all members that didn't have
-          // their access specified are private.
+          // This is a class and all members that didn't have their access
+          // specified are private.
           m_ast.SetDefaultAccessForRecordFields(
               m_ast.GetAsRecordDecl(clang_type), eAccessPrivate,
               &member_accessibilities.front(), member_accessibilities.size());
@@ -2419,14 +2398,13 @@
                   module->ReportError(":: Try compiling the source file with "
                                       "-fstandalone-debug.");
 
-                // We have no choice other than to pretend that the base class
-                // is complete. If we don't do this, clang will crash when we
-                // call setBases() inside of
-                // "clang_type.SetBaseClassesForClassType()"
-                // below. Since we provide layout assistance, all ivars in this
-                // class and other classes will be fine, this is the best we can
-                // do
-                // short of crashing.
+                // We have no choice other than to pretend that the base
+                // class is complete. If we don't do this, clang will
+                // crash when we call setBases() inside of
+                // "clang_type.SetBaseClassesForClassType()" below. Since
+                // we provide layout assistance, all ivars in this class
+                // and other classes will be fine, this is the best we can
+                // do short of crashing.
                 if (ClangASTContext::StartTagDeclarationDefinition(
                         base_class_type)) {
                   ClangASTContext::CompleteTagDeclarationDefinition(
@@ -2439,8 +2417,8 @@
                                            &base_classes.front(),
                                            base_classes.size());
 
-          // Clang will copy each CXXBaseSpecifier in "base_classes"
-          // so we have to free them all.
+          // Clang will copy each CXXBaseSpecifier in "base_classes" so we
+          // have to free them all.
           ClangASTContext::DeleteBaseClassSpecifiers(&base_classes.front(),
                                                      base_classes.size());
         }
@@ -2749,10 +2727,8 @@
                Language::LanguageIsCPlusPlus(die.GetLanguage()) && name &&
                strcmp(name, "main") != 0) {
         // If the mangled name is not present in the DWARF, generate the
-        // demangled name
-        // using the decl context. We skip if the function is "main" as its name
-        // is
-        // never mangled.
+        // demangled name using the decl context. We skip if the function
+        // is "main" as its name is never mangled.
         bool is_static = false;
         bool is_variadic = false;
         bool has_template_params = false;
@@ -2925,9 +2901,9 @@
                   member_byte_offset = memberOffset.ResolveValue(NULL).UInt();
                 }
               } else {
-                // With DWARF 3 and later, if the value is an integer constant,
-                // this form value is the offset in bytes from the beginning
-                // of the containing entity.
+                // With DWARF 3 and later, if the value is an integer
+                // constant, this form value is the offset in bytes from
+                // the beginning of the containing entity.
                 member_byte_offset = form_value.Unsigned();
               }
               break;
@@ -2982,8 +2958,8 @@
             prop_setter_name = prop_setter_method.GetSelector().GetCString();
           }
 
-          // If the names haven't been provided, they need to be
-          // filled in.
+          // If the names haven't been provided, they need to be filled
+          // in.
 
           if (!prop_getter_name) {
             prop_getter_name = prop_name;
@@ -2999,38 +2975,38 @@
           }
         }
 
-        // Clang has a DWARF generation bug where sometimes it
-        // represents fields that are references with bad byte size
-        // and bit size/offset information such as:
+        // Clang has a DWARF generation bug where sometimes it represents
+        // fields that are references with bad byte size and bit
+        // size/offset information such as:
         //
         //  DW_AT_byte_size( 0x00 )
         //  DW_AT_bit_size( 0x40 )
         //  DW_AT_bit_offset( 0xffffffffffffffc0 )
         //
-        // So check the bit offset to make sure it is sane, and if
-        // the values are not sane, remove them. If we don't do this
-        // then we will end up with a crash if we try to use this
-        // type in an expression when clang becomes unhappy with its
-        // recycled debug info.
+        // So check the bit offset to make sure it is sane, and if the
+        // values are not sane, remove them. If we don't do this then we
+        // will end up with a crash if we try to use this type in an
+        // expression when clang becomes unhappy with its recycled debug
+        // info.
 
         if (byte_size == 0 && bit_offset < 0) {
           bit_size = 0;
           bit_offset = 0;
         }
 
-        // FIXME: Make Clang ignore Objective-C accessibility for expressions
+        // FIXME: Make Clang ignore Objective-C accessibility for
+        // expressions
         if (class_language == eLanguageTypeObjC ||
             class_language == eLanguageTypeObjC_plus_plus)
           accessibility = eAccessNone;
 
         if (member_idx == 0 && !is_artificial && name &&
             (strstr(name, "_vptr$") == name)) {
-          // Not all compilers will mark the vtable pointer
-          // member as artificial (llvm-gcc). We can't have
-          // the virtual members in our classes otherwise it
-          // throws off all child offsets since we end up
-          // having and extra pointer sized member in our
-          // class layouts.
+          // Not all compilers will mark the vtable pointer member as
+          // artificial (llvm-gcc). We can't have the virtual members in
+          // our classes otherwise it throws off all child offsets since
+          // we end up having and extra pointer sized member in our class
+          // layouts.
           is_artificial = true;
         }
 
@@ -3070,11 +3046,11 @@
                 /////////////////////////////////////////////////////////////
                 // How to locate a field given the DWARF debug information
                 //
-                // AT_byte_size indicates the size of the word in which the
-                // bit offset must be interpreted.
+                // AT_byte_size indicates the size of the word in which
+                // the bit offset must be interpreted.
                 //
-                // AT_data_member_location indicates the byte offset of the
-                // word from the base address of the structure.
+                // AT_data_member_location indicates the byte offset of
+                // the word from the base address of the structure.
                 //
                 // AT_bit_offset indicates how many bits into the word
                 // (according to the host endianness) the low-order bit of
@@ -3118,29 +3094,27 @@
                 // Update the field bit offset we will report for layout
                 field_bit_offset = this_field_info.bit_offset;
 
-                // If the member to be emitted did not start on a character
-                // boundary and there is
-                // empty space between the last field and this one, then we need
-                // to emit an
-                // anonymous member filling up the space up to its start.  There
-                // are three cases
-                // here:
+                // If the member to be emitted did not start on a
+                // character boundary and there is empty space between the
+                // last field and this one, then we need to emit an
+                // anonymous member filling up the space up to its start.
+                // There are three cases here:
                 //
-                // 1 If the previous member ended on a character boundary, then
-                // we can emit an
+                // 1 If the previous member ended on a character boundary,
+                // then we can emit an
                 //   anonymous member starting at the most recent character
                 //   boundary.
                 //
-                // 2 If the previous member did not end on a character boundary
-                // and the distance
+                // 2 If the previous member did not end on a character
+                // boundary and the distance
                 //   from the end of the previous member to the current member
                 //   is less than a
                 //   word width, then we can emit an anonymous member starting
                 //   right after the
                 //   previous member and right before this member.
                 //
-                // 3 If the previous member did not end on a character boundary
-                // and the distance
+                // 3 If the previous member did not end on a character
+                // boundary and the distance
                 //   from the end of the previous member to the current member
                 //   is greater than
                 //   or equal a word width, then we act as in Case 1.
@@ -3148,11 +3122,10 @@
                 const uint64_t character_width = 8;
                 const uint64_t word_width = 32;
 
-                // Objective-C has invalid DW_AT_bit_offset values in older
-                // versions
-                // of clang, so we have to be careful and only insert unnamed
-                // bitfields
-                // if we have a new enough clang.
+                // Objective-C has invalid DW_AT_bit_offset values in
+                // older versions of clang, so we have to be careful and
+                // only insert unnamed bitfields if we have a new enough
+                // clang.
                 bool detect_unnamed_bitfields = true;
 
                 if (class_language == eLanguageTypeObjC ||
@@ -3214,11 +3187,11 @@
                 member_clang_type.GetCompleteType();
 
               {
-                // Older versions of clang emit array[0] and array[1] in the
-                // same way (<rdar://problem/12566646>).
-                // If the current field is at the end of the structure, then
-                // there is definitely no room for extra
-                // elements and we override the type to array[0].
+                // Older versions of clang emit array[0] and array[1] in
+                // the same way (<rdar://problem/12566646>). If the
+                // current field is at the end of the structure, then
+                // there is definitely no room for extra elements and we
+                // override the type to array[0].
 
                 CompilerType member_array_element_type;
                 uint64_t member_array_size;
@@ -3270,12 +3243,12 @@
                       die.GetOffset(), name,
                       sc.comp_unit ? sc.comp_unit->GetPath().c_str()
                                    : "the source file");
-                // We have no choice other than to pretend that the member class
-                // is complete. If we don't do this, clang will crash when
-                // trying
-                // to layout the class. Since we provide layout assistance, all
-                // ivars in this class and other classes will be fine, this is
-                // the best we can do short of crashing.
+                // We have no choice other than to pretend that the member
+                // class is complete. If we don't do this, clang will
+                // crash when trying to layout the class. Since we provide
+                // layout assistance, all ivars in this class and other
+                // classes will be fine, this is the best we can do short
+                // of crashing.
                 if (ClangASTContext::StartTagDeclarationDefinition(
                         member_clang_type)) {
                   ClangASTContext::CompleteTagDeclarationDefinition(
@@ -3396,9 +3369,9 @@
                   member_byte_offset = memberOffset.ResolveValue(NULL).UInt();
                 }
               } else {
-                // With DWARF 3 and later, if the value is an integer constant,
-                // this form value is the offset in bytes from the beginning
-                // of the containing entity.
+                // With DWARF 3 and later, if the value is an integer
+                // constant, this form value is the offset in bytes from
+                // the beginning of the containing entity.
                 member_byte_offset = form_value.Unsigned();
               }
               break;
@@ -3443,20 +3416,18 @@
               is_virtual, is_base_of_class));
 
           if (is_virtual) {
-            // Do not specify any offset for virtual inheritance. The DWARF
-            // produced by clang doesn't
-            // give us a constant offset, but gives us a DWARF expressions that
-            // requires an actual object
-            // in memory. the DW_AT_data_member_location for a virtual base
-            // class looks like:
+            // Do not specify any offset for virtual inheritance. The
+            // DWARF produced by clang doesn't give us a constant offset,
+            // but gives us a DWARF expressions that requires an actual
+            // object in memory. the DW_AT_data_member_location for a
+            // virtual base class looks like:
             //      DW_AT_data_member_location( DW_OP_dup, DW_OP_deref,
             //      DW_OP_constu(0x00000018), DW_OP_minus, DW_OP_deref,
             //      DW_OP_plus )
-            // Given this, there is really no valid response we can give to
-            // clang for virtual base
-            // class offsets, and this should eventually be removed from
-            // LayoutRecordType() in the external
-            // AST source in clang.
+            // Given this, there is really no valid response we can give
+            // to clang for virtual base class offsets, and this should
+            // eventually be removed from LayoutRecordType() in the
+            // external AST source in clang.
           } else {
             layout_info.base_offsets.insert(std::make_pair(
                 ast->GetAsCXXRecordDecl(
@@ -3545,9 +3516,9 @@
         bool skip = false;
         if (skip_artificial) {
           if (is_artificial) {
-            // In order to determine if a C++ member function is
-            // "const" we have to look at the const-ness of "this"...
-            // Ugly, but that
+            // In order to determine if a C++ member function is "const"
+            // we have to look at the const-ness of "this"... Ugly, but
+            // that
             if (arg_idx == 0) {
               if (DeclKindIsCXXClass(containing_decl_ctx->getDeclKind())) {
                 // Often times compilers omit the "this" name for the
@@ -3573,8 +3544,8 @@
             skip = true;
           } else {
 
-            // HACK: Objective C formal parameters "self" and "_cmd"
-            // are not marked as artificial in the DWARF...
+            // HACK: Objective C formal parameters "self" and "_cmd" are
+            // not marked as artificial in the DWARF...
             CompileUnit *comp_unit = die.GetLLDBCompileUnit();
             if (comp_unit) {
               switch (comp_unit->GetLanguage()) {
@@ -3617,9 +3588,9 @@
     case DW_TAG_template_value_parameter:
     case DW_TAG_GNU_template_parameter_pack:
       // The one caller of this was never using the template_param_infos,
-      // and the local variable was taking up a large amount of stack space
-      // in SymbolFileDWARF::ParseType() so this was removed. If we ever need
-      // the template params back, we can add them back.
+      // and the local variable was taking up a large amount of stack
+      // space in SymbolFileDWARF::ParseType() so this was removed. If we
+      // ever need the template params back, we can add them back.
       // ParseTemplateDIE (dwarf_cu, die, template_param_infos);
       has_template_params = true;
       break;
@@ -3956,8 +3927,8 @@
 clang::NamespaceDecl *
 DWARFASTParserClang::ResolveNamespaceDIE(const DWARFDIE &die) {
   if (die && die.Tag() == DW_TAG_namespace) {
-    // See if we already parsed this namespace DIE and associated it with a
-    // uniqued namespace declaration
+    // See if we already parsed this namespace DIE and associated it with
+    // a uniqued namespace declaration
     clang::NamespaceDecl *namespace_decl =
         static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die.GetDIE()]);
     if (namespace_decl)
@@ -4043,9 +4014,9 @@
   if (src_class_die.Tag() != dst_class_die.Tag())
     return false;
 
-  // We need to complete the class type so we can get all of the method types
-  // parsed so we can then unique those types to their equivalent counterparts
-  // in "dst_cu" and "dst_class_die"
+  // We need to complete the class type so we can get all of the method
+  // types parsed so we can then unique those types to their equivalent
+  // counterparts in "dst_cu" and "dst_class_die"
   class_type->GetFullCompilerType();
 
   DWARFDIE src_die;
@@ -4057,10 +4028,11 @@
   for (src_die = src_class_die.GetFirstChild(); src_die.IsValid();
        src_die = src_die.GetSibling()) {
     if (src_die.Tag() == DW_TAG_subprogram) {
-      // Make sure this is a declaration and not a concrete instance by looking
-      // for DW_AT_declaration set to 1. Sometimes concrete function instances
-      // are placed inside the class definitions and shouldn't be included in
-      // the list of things are are tracking here.
+      // Make sure this is a declaration and not a concrete instance by
+      // looking for DW_AT_declaration set to 1. Sometimes concrete
+      // function instances are placed inside the class definitions and
+      // shouldn't be included in the list of things are are tracking
+      // here.
       if (src_die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0) == 1) {
         const char *src_name = src_die.GetMangledName();
         if (src_name) {
@@ -4076,10 +4048,11 @@
   for (dst_die = dst_class_die.GetFirstChild(); dst_die.IsValid();
        dst_die = dst_die.GetSibling()) {
     if (dst_die.Tag() == DW_TAG_subprogram) {
-      // Make sure this is a declaration and not a concrete instance by looking
-      // for DW_AT_declaration set to 1. Sometimes concrete function instances
-      // are placed inside the class definitions and shouldn't be included in
-      // the list of things are are tracking here.
+      // Make sure this is a declaration and not a concrete instance by
+      // looking for DW_AT_declaration set to 1. Sometimes concrete
+      // function instances are placed inside the class definitions and
+      // shouldn't be included in the list of things are are tracking
+      // here.
       if (dst_die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0) == 1) {
         const char *dst_name = dst_die.GetMangledName();
         if (dst_name) {
@@ -4154,8 +4127,8 @@
 
   // Now do the work of linking the DeclContexts and Types.
   if (fast_path) {
-    // We can do this quickly.  Just run across the tables index-for-index since
-    // we know each node has matching names and tags.
+    // We can do this quickly.  Just run across the tables index-for-index
+    // since we know each node has matching names and tags.
     for (idx = 0; idx < src_size; ++idx) {
       src_die = src_name_to_die.GetValueAtIndexUnchecked(idx);
       dst_die = dst_name_to_die.GetValueAtIndexUnchecked(idx);
Index: source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.cpp
@@ -157,7 +157,8 @@
           Type *type = dwarf->ResolveTypeUID(encoding_uid);
           if (type) {
             if (go_kind == 0 && type->GetName() == type_name_const_str) {
-              // Go emits extra typedefs as a forward declaration. Ignore these.
+              // Go emits extra typedefs as a forward declaration. Ignore
+              // these.
               dwarf->m_die_to_type[die.GetDIE()] = type;
               return type->shared_from_this();
             }
@@ -212,10 +213,10 @@
 
         // TODO(ribrdb): Do we need this?
 
-        // UniqueDWARFASTType is large, so don't create a local variables on the
-        // stack, put it on the heap. This function is often called recursively
-        // and clang isn't good and sharing the stack space for variables in
-        // different blocks.
+        // UniqueDWARFASTType is large, so don't create a local variables
+        // on the stack, put it on the heap. This function is often called
+        // recursively and clang isn't good and sharing the stack space
+        // for variables in different blocks.
         std::unique_ptr<UniqueDWARFASTType> unique_ast_entry_ap(
             new UniqueDWARFASTType());
 
@@ -224,11 +225,10 @@
             dwarf->GetUniqueDWARFASTTypeMap().Find(
                 type_name_const_str, die, decl,
                 byte_size_valid ? byte_size : -1, *unique_ast_entry_ap)) {
-          // We have already parsed this type or from another
-          // compile unit. GCC loves to use the "one definition
-          // rule" which can result in multiple definitions
-          // of the same class over and over in each compile
-          // unit.
+          // We have already parsed this type or from another compile
+          // unit. GCC loves to use the "one definition rule" which can
+          // result in multiple definitions of the same class over and
+          // over in each compile unit.
           type_sp = unique_ast_entry_ap->m_type_sp;
           if (type_sp) {
             dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
@@ -254,9 +254,9 @@
                                Type::eEncodingIsUID, &decl, compiler_type,
                                Type::eResolveStateForward));
 
-        // Add our type to the unique type map so we don't
-        // end up creating many copies of the same type over
-        // and over in the ASTContext for our module
+        // Add our type to the unique type map so we don't end up creating
+        // many copies of the same type over and over in the ASTContext
+        // for our module
         unique_ast_entry_ap->m_type_sp = type_sp;
         unique_ast_entry_ap->m_die = die;
         unique_ast_entry_ap->m_declaration = decl;
@@ -265,25 +265,26 @@
                                                  *unique_ast_entry_ap);
 
         if (!is_forward_declaration) {
-          // Always start the definition for a class type so that
-          // if the class has child classes or types that require
-          // the class to be created for use as their decl contexts
-          // the class will be ready to accept these child definitions.
+          // Always start the definition for a class type so that if the
+          // class has child classes or types that require the class to be
+          // created for use as their decl contexts the class will be
+          // ready to accept these child definitions.
           if (die.HasChildren() == false) {
             // No children for this struct/union/class, lets finish it
             m_ast.CompleteStructType(compiler_type);
           } else if (compiler_type_was_created) {
-            // Leave this as a forward declaration until we need
-            // to know the details of the type. lldb_private::Type
-            // will automatically call the SymbolFile virtual function
-            // "SymbolFileDWARF::CompleteType(Type *)"
-            // When the definition needs to be defined.
+            // Leave this as a forward declaration until we need to know
+            // the details of the type. lldb_private::Type will
+            // automatically call the SymbolFile virtual function
+            // "SymbolFileDWARF::CompleteType(Type *)" When the definition
+            // needs to be defined.
             dwarf->m_forward_decl_die_to_clang_type[die.GetDIE()] =
                 compiler_type.GetOpaqueQualType();
             dwarf->m_forward_decl_clang_type_to_die[compiler_type
                                                         .GetOpaqueQualType()] =
                 die.GetDIERef();
-            // SetHasExternalStorage (compiler_type.GetOpaqueQualType(), true);
+            // SetHasExternalStorage (compiler_type.GetOpaqueQualType(),
+            // true);
           }
         }
       } break;
@@ -337,8 +338,8 @@
           ParseChildParameters(sc, die, is_variadic, function_param_types);
         }
 
-        // compiler_type will get the function prototype clang type after this
-        // call
+        // compiler_type will get the function prototype clang type after
+        // this call
         compiler_type = m_ast.CreateFunctionType(
             type_name_const_str, function_param_types.data(),
             function_param_types.size(), is_variadic);
@@ -444,8 +445,8 @@
           type_sp->SetSymbolContextScope(symbol_context_scope);
         }
 
-        // We are ready to put this type into the uniqued list up at the module
-        // level
+        // We are ready to put this type into the uniqued list up at the
+        // module level
         type_list->Insert(type_sp);
 
         dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
@@ -668,9 +669,9 @@
                   member_byte_offset = memberOffset.ResolveValue(NULL).UInt();
                 }
               } else {
-                // With DWARF 3 and later, if the value is an integer constant,
-                // this form value is the offset in bytes from the beginning
-                // of the containing entity.
+                // With DWARF 3 and later, if the value is an integer
+                // constant, this form value is the offset in bytes from
+                // the beginning of the containing entity.
                 member_byte_offset = form_value.Unsigned();
               }
               break;
Index: source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp
@@ -264,8 +264,8 @@
   dwarf->GetUniqueDWARFASTTypeMap().Insert(name, unique_ast_entry);
 
   if (!is_forward_declaration) {
-    // Leave this as a forward declaration until we need to know the details of
-    // the type
+    // Leave this as a forward declaration until we need to know the
+    // details of the type
     dwarf->GetForwardDeclDieToClangType()[die.GetDIE()] =
         compiler_type.GetOpaqueQualType();
     dwarf->GetForwardDeclClangTypeToDie()[compiler_type.GetOpaqueQualType()] =
@@ -488,7 +488,8 @@
             member_byte_offset = form_value.Unsigned();
             break;
           case DW_AT_accessibility:
-            // In java all base class is public so we can ignore this attribute
+            // In java all base class is public so we can ignore this
+            // attribute
             break;
           default:
             assert(false && "Unhandled attribute for DW_TAG_member");
Index: source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp
@@ -53,7 +53,8 @@
       return cu_sp;
     }
 
-    // reset the offset to where we tried to parse from if anything went wrong
+    // reset the offset to where we tried to parse from if anything went
+    // wrong
     *offset_ptr = cu_sp->m_offset;
   }
 
Index: source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp
@@ -362,8 +362,8 @@
 DWARFDIE::GetContainingDWOModuleDIE() const {
   if (IsValid()) {
     DWARFDIE top_module_die;
-    // Now make sure this DIE is scoped in a DW_TAG_module tag and return true
-    // if so
+    // Now make sure this DIE is scoped in a DW_TAG_module tag and return
+    // true if so
     for (DWARFDIE parent = GetParent(); parent.IsValid();
          parent = parent.GetParent()) {
       const dw_tag_t tag = parent.Tag();
Index: source/Plugins/SymbolFile/DWARF/DWARFDebugAbbrev.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFDebugAbbrev.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFDebugAbbrev.cpp
@@ -115,13 +115,13 @@
 //----------------------------------------------------------------------
 // Encode
 //
-// Encode the abbreviation table onto the end of the buffer provided
-// into a byte representation as would be found in a ".debug_abbrev"
-// debug information section.
+// Encode the abbreviation table onto the end of the buffer provided into
+// a byte representation as would be found in a ".debug_abbrev" debug
+// information section.
 //----------------------------------------------------------------------
 // void
-// DWARFAbbreviationDeclarationSet::Encode(BinaryStreamBuf& debug_abbrev_buf)
-// const
+// DWARFAbbreviationDeclarationSet::Encode(BinaryStreamBuf&
+// debug_abbrev_buf) const
 //{
 //  DWARFAbbreviationDeclarationCollConstIter pos;
 //  DWARFAbbreviationDeclarationCollConstIter end = m_decls.end();
Index: source/Plugins/SymbolFile/DWARF/DWARFDebugArangeSet.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFDebugArangeSet.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFDebugArangeSet.cpp
@@ -47,25 +47,23 @@
     return;
 
   // Iterate through all arange descriptors and combine any ranges that
-  // overlap or have matching boundaries. The m_arange_descriptors are assumed
-  // to be in ascending order after being built by adding descriptors
-  // using the AddDescriptor method.
+  // overlap or have matching boundaries. The m_arange_descriptors are
+  // assumed to be in ascending order after being built by adding
+  // descriptors using the AddDescriptor method.
   uint32_t i = 0;
   while (i + 1 < m_arange_descriptors.size()) {
     if (m_arange_descriptors[i].end_address() >=
         m_arange_descriptors[i + 1].address) {
-      // The current range ends at or exceeds the start of the next address
-      // range.
-      // Compute the max end address between the two and use that to make the
-      // new
-      // length.
+      // The current range ends at or exceeds the start of the next
+      // address range. Compute the max end address between the two and
+      // use that to make the new length.
       const dw_addr_t max_end_addr =
           std::max(m_arange_descriptors[i].end_address(),
                    m_arange_descriptors[i + 1].end_address());
       m_arange_descriptors[i].length =
           max_end_addr - m_arange_descriptors[i].address;
-      // Now remove the next entry as it was just combined with the previous
-      // one.
+      // Now remove the next entry as it was just combined with the
+      // previous one.
       m_arange_descriptors.erase(m_arange_descriptors.begin() + i + 1);
     } else {
       // Discontiguous address range, just proceed to the next one.
@@ -82,8 +80,8 @@
 }
 
 //----------------------------------------------------------------------
-// Add a range descriptor and keep things sorted so we can easily
-// compact the ranges before being saved or used.
+// Add a range descriptor and keep things sorted so we can easily compact
+// the ranges before being saved or used.
 //----------------------------------------------------------------------
 void DWARFDebugArangeSet::AddDescriptor(
     const DWARFDebugArangeSet::Descriptor &range) {
@@ -103,15 +101,15 @@
         // Non-contiguous entries, add this one before the found entry
         m_arange_descriptors.insert(pos, range);
       } else if (range_end_addr == pos->address) {
-        // The top end of 'range' is the lower end of the entry
-        // pointed to by 'pos'. We can combine range with the
-        // entry we found by setting the starting address and
-        // increasing the length since they don't overlap.
+        // The top end of 'range' is the lower end of the entry pointed to
+        // by 'pos'. We can combine range with the entry we found by
+        // setting the starting address and increasing the length since
+        // they don't overlap.
         pos->address = range.address;
         pos->length += range.length;
       } else {
-        // We can combine these two and make sure the largest end
-        // address is used to make end address.
+        // We can combine these two and make sure the largest end address
+        // is used to make end address.
         pos->address = range.address;
         pos->length = std::max(found_end_addr, range_end_addr) - pos->address;
       }
@@ -142,38 +140,37 @@
 
     // 7.20 Address Range Table
     //
-    // Each set of entries in the table of address ranges contained in
-    // the .debug_aranges section begins with a header consisting of: a
-    // 4-byte length containing the length of the set of entries for this
+    // Each set of entries in the table of address ranges contained in the
+    // .debug_aranges section begins with a header consisting of: a 4-byte
+    // length containing the length of the set of entries for this
     // compilation unit, not including the length field itself; a 2-byte
     // version identifier containing the value 2 for DWARF Version 2; a
     // 4-byte offset into the.debug_infosection; a 1-byte unsigned integer
-    // containing the size in bytes of an address (or the offset portion of
-    // an address for segmented addressing) on the target system; and a
+    // containing the size in bytes of an address (or the offset portion
+    // of an address for segmented addressing) on the target system; and a
     // 1-byte unsigned integer containing the size in bytes of a segment
-    // descriptor on the target system. This header is followed by a series
-    // of tuples. Each tuple consists of an address and a length, each in
-    // the size appropriate for an address on the target architecture.
+    // descriptor on the target system. This header is followed by a
+    // series of tuples. Each tuple consists of an address and a length,
+    // each in the size appropriate for an address on the target
+    // architecture.
     m_header.length = data.GetDWARFInitialLength(offset_ptr);
     m_header.version = data.GetU16(offset_ptr);
     m_header.cu_offset = data.GetDWARFOffset(offset_ptr);
     m_header.addr_size = data.GetU8(offset_ptr);
     m_header.seg_size = data.GetU8(offset_ptr);
 
-    // Try to avoid reading invalid arange sets by making sure:
-    // 1 - the version looks good
-    // 2 - the address byte size looks plausible
-    // 3 - the length seems to make sense
-    // size looks plausible
+    // Try to avoid reading invalid arange sets by making sure: 1 - the
+    // version looks good 2 - the address byte size looks plausible 3 -
+    // the length seems to make sense size looks plausible
     if ((m_header.version >= 2 && m_header.version <= 5) &&
         (m_header.addr_size == 4 || m_header.addr_size == 8) &&
         (m_header.length > 0)) {
       if (data.ValidOffset(m_offset + sizeof(m_header.length) +
                            m_header.length - 1)) {
-        // The first tuple following the header in each set begins at an offset
-        // that is a multiple of the size of a single tuple (that is, twice the
-        // size of an address). The header is padded, if necessary, to the
-        // appropriate boundary.
+        // The first tuple following the header in each set begins at an
+        // offset that is a multiple of the size of a single tuple (that
+        // is, twice the size of an address). The header is padded, if
+        // necessary, to the appropriate boundary.
         const uint32_t header_size = *offset_ptr - m_offset;
         const uint32_t tuple_size = m_header.addr_size << 1;
         uint32_t first_tuple_offset = 0;
Index: source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp
@@ -120,8 +120,9 @@
 }
 
 bool DWARFDebugInfo::ContainsCompileUnit(const DWARFUnit *cu) const {
-  // Not a verify efficient function, but it is handy for use in assertions
-  // to make sure that a compile unit comes from a debug information file.
+  // Not a verify efficient function, but it is handy for use in
+  // assertions to make sure that a compile unit comes from a debug
+  // information file.
   CompileUnitColl::const_iterator end_pos = m_compile_units.end();
   CompileUnitColl::const_iterator pos;
 
@@ -144,7 +145,8 @@
   if (cu_offset != DW_INVALID_OFFSET) {
     ParseCompileUnitHeadersIfNeeded();
 
-    // Watch out for single compile unit executable as they are pretty common
+    // Watch out for single compile unit executable as they are pretty
+    // common
     const size_t num_cus = m_compile_units.size();
     if (num_cus == 1) {
       if (m_compile_units[0]->GetOffset() == cu_offset) {
@@ -183,7 +185,8 @@
 
   DWARFUnitSP cu_sp;
 
-  // Watch out for single compile unit executable as they are pretty common
+  // Watch out for single compile unit executable as they are pretty
+  // common
   const size_t num_cus = m_compile_units.size();
   if (num_cus == 1) {
     if (m_compile_units[0]->ContainsDIEOffset(die_offset))
@@ -227,12 +230,12 @@
 //----------------------------------------------------------------------
 // Parse
 //
-// Parses the .debug_info section and uses the .debug_abbrev section
-// and various other sections in the SymbolFileDWARF class and calls the
+// Parses the .debug_info section and uses the .debug_abbrev section and
+// various other sections in the SymbolFileDWARF class and calls the
 // supplied callback function each time a compile unit header, or debug
-// information entry is successfully parsed. This function can be used
-// for different tasks such as parsing the file contents into a
-// structured data, dumping, verifying and much more.
+// information entry is successfully parsed. This function can be used for
+// different tasks such as parsing the file contents into a structured
+// data, dumping, verifying and much more.
 //----------------------------------------------------------------------
 void DWARFDebugInfo::Parse(SymbolFileDWARF *dwarf2Data, Callback callback,
                            void *userData) {
@@ -246,18 +249,18 @@
       const dw_offset_t next_cu_offset = cu->GetNextCompileUnitOffset();
 
       depth = 0;
-      // Call the callback function with no DIE pointer for the compile unit
-      // and get the offset that we are to continue to parse from
+      // Call the callback function with no DIE pointer for the compile
+      // unit and get the offset that we are to continue to parse from
       offset = callback(dwarf2Data, cu.get(), NULL, offset, depth, userData);
 
       // Make sure we are within our compile unit
       if (offset < next_cu_offset) {
-        // We are in our compile unit, parse starting at the offset
-        // we were told to parse
+        // We are in our compile unit, parse starting at the offset we
+        // were told to parse
         bool done = false;
         while (!done && die.Extract(dwarf2Data, cu.get(), &offset)) {
-          // Call the callback function with DIE pointer that falls within the
-          // compile unit
+          // Call the callback function with DIE pointer that falls within
+          // the compile unit
           offset =
               callback(dwarf2Data, cu.get(), &die, offset, depth, userData);
 
@@ -272,8 +275,8 @@
       }
 
       // Make sure the offset returned is valid, and if not stop parsing.
-      // Returning DW_INVALID_OFFSET from this callback is a good way to end
-      // all parsing
+      // Returning DW_INVALID_OFFSET from this callback is a good way to
+      // end all parsing
       if (!dwarf2Data->get_debug_info_data().ValidOffset(offset))
         break;
 
@@ -304,8 +307,8 @@
 // that gets called each time a compile unit header or debug information
 // entry is successfully parsed.
 //
-// This function dump DWARF information and obey recurse depth and
-// whether a single DIE is to be dumped (or all of the data).
+// This function dump DWARF information and obey recurse depth and whether
+// a single DIE is to be dumped (or all of the data).
 //----------------------------------------------------------------------
 static dw_offset_t DumpCallback(SymbolFileDWARF *dwarf2Data,
                                 DWARFUnit *cu, DWARFDebugInfoEntry *die,
@@ -344,8 +347,8 @@
         // Note that we found the DIE we were looking for
         dumpInfo->found_die = true;
 
-        // Since we are dumping a single DIE, if there are no children we are
-        // done!
+        // Since we are dumping a single DIE, if there are no children we
+        // are done!
         if (!die->HasChildren() || dumpInfo->recurse_depth == 0)
           return DW_INVALID_OFFSET; // Return an invalid address to end parsing
       } else if (dumpInfo->found_die) {
@@ -353,9 +356,9 @@
         if (curr_depth <= dumpInfo->found_depth)
           return DW_INVALID_OFFSET;
 
-        // We have already found our DIE and are printing it's children. Obey
-        // our recurse depth and return an invalid offset if we get done
-        // dumping all of the children
+        // We have already found our DIE and are printing it's children.
+        // Obey our recurse depth and return an invalid offset if we get
+        // done dumping all of the children
         if (dumpInfo->recurse_depth == UINT32_MAX ||
             curr_depth <= dumpInfo->found_depth + dumpInfo->recurse_depth)
           die->Dump(dwarf2Data, cu, *s, 0);
@@ -418,7 +421,8 @@
           //  dumping the requested DIE...
           //  return dumpInfo->die_offset;
         } else {
-          // Skip to the next compile unit as the DIE isn't in the current one!
+          // Skip to the next compile unit as the DIE isn't in the current
+          // one!
           if (cu) {
             return cu->GetNextCompileUnitOffset();
           } else {
@@ -442,8 +446,8 @@
 // cases will obey a "recurse_depth" or how deep to traverse into the
 // children of each DIE entry. A recurse_depth of zero will dump all
 // compile unit headers. A recurse_depth of 1 will dump all compile unit
-// headers and the DW_TAG_compile unit tags. A depth of 2 will also
-// dump all types and functions.
+// headers and the DW_TAG_compile unit tags. A depth of 2 will also dump
+// all types and functions.
 //----------------------------------------------------------------------
 void DWARFDebugInfo::Dump(Stream *s, SymbolFileDWARF *dwarf2Data,
                           const uint32_t die_offset,
Index: source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp
@@ -81,8 +81,8 @@
           form_is_indirect = false;
           uint32_t form_size = 0;
           switch (form) {
-          // Blocks if inlined data that have a length field and the data bytes
-          // inlined in the .debug_info
+          // Blocks if inlined data that have a length field and the data
+          // bytes inlined in the .debug_info
           case DW_FORM_exprloc:
           case DW_FORM_block:
             form_size = debug_info_data.GetULEB128(&offset);
@@ -244,9 +244,8 @@
               form_is_indirect = false;
               uint32_t form_size = 0;
               switch (form) {
-              // Blocks if inlined data that have a length field and the data
-              // bytes
-              // inlined in the .debug_info
+              // Blocks if inlined data that have a length field and the
+              // data bytes inlined in the .debug_info
               case DW_FORM_exprloc:
               case DW_FORM_block:
                 form_size = debug_info_data.GetULEB128(&offset);
@@ -659,8 +658,8 @@
 // DumpAttribute
 //
 // 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).
+// special display of attributes is done (disassemble location lists, show
+// enumeration values for attributes, etc).
 //----------------------------------------------------------------------
 void DWARFDebugInfoEntry::DumpAttribute(
     SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
@@ -716,9 +715,9 @@
       DWARFExpression::PrintDWARFExpression(
           s, locationData, DWARFUnit::GetAddressByteSize(cu), 4, false);
     } 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
+      // 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) {
         DWARFExpression::PrintDWARFLocationList(
@@ -759,9 +758,9 @@
 
 //----------------------------------------------------------------------
 // Get all attribute values for a given DIE, including following any
-// specification or abstract origin attributes and including those in
-// the results. Any duplicate attributes will have the first instance
-// take precedence (this can happen for declaration attributes).
+// specification or abstract origin attributes and including those in the
+// results. Any duplicate attributes will have the first instance take
+// precedence (this can happen for declaration attributes).
 //----------------------------------------------------------------------
 size_t DWARFDebugInfoEntry::GetAttributes(
     const DWARFUnit *cu, DWARFFormValue::FixedFormSizes fixed_form_sizes,
@@ -796,16 +795,16 @@
     for (i = 0; i < num_attributes; ++i) {
       abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form);
 
-      // If we are tracking down DW_AT_specification or DW_AT_abstract_origin
-      // attributes, the depth will be non-zero. We need to omit certain
-      // attributes that don't make sense.
+      // If we are tracking down DW_AT_specification or
+      // DW_AT_abstract_origin attributes, the depth will be non-zero. We
+      // need to omit certain attributes that don't make sense.
       switch (attr) {
       case DW_AT_sibling:
       case DW_AT_declaration:
         if (curr_depth > 0) {
-          // This attribute doesn't make sense when combined with
-          // the DIE that references this DIE. We know a DIE is
-          // referencing this DIE because curr_depth is not zero
+          // This attribute doesn't make sense when combined with the DIE
+          // that references this DIE. We know a DIE is referencing this
+          // DIE because curr_depth is not zero
           break;
         }
         LLVM_FALLTHROUGH;
@@ -841,9 +840,9 @@
 // GetAttributeValue
 //
 // Get the value of an attribute and return the .debug_info offset of the
-// attribute if it was properly extracted into form_value, or zero
-// if we fail since an offset of zero is invalid for an attribute (it
-// would be a compile unit header).
+// attribute if it was properly extracted into form_value, or zero if we
+// fail since an offset of zero is invalid for an attribute (it would be a
+// compile unit header).
 //----------------------------------------------------------------------
 dw_offset_t DWARFDebugInfoEntry::GetAttributeValue(
     SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
@@ -930,8 +929,8 @@
 //
 // Get the value of an attribute as a string return it. The resulting
 // pointer to the string data exists within the supplied SymbolFileDWARF
-// and will only be available as long as the SymbolFileDWARF is still around
-// and it's content doesn't change.
+// and will only be available as long as the SymbolFileDWARF is still
+// around and it's content doesn't change.
 //----------------------------------------------------------------------
 const char *DWARFDebugInfoEntry::GetAttributeValueAsString(
     SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
@@ -979,8 +978,8 @@
 //----------------------------------------------------------------------
 // GetAttributeValueAsReference
 //
-// Get the value of an attribute as reference and fix up and compile
-// unit relative offsets as needed.
+// Get the value of an attribute as reference and fix up and compile unit
+// relative offsets as needed.
 //----------------------------------------------------------------------
 uint64_t DWARFDebugInfoEntry::GetAttributeValueAsReference(
     SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
@@ -1007,8 +1006,8 @@
 //----------------------------------------------------------------------
 // GetAttributeHighPC
 //
-// Get the hi_pc, adding hi_pc to lo_pc when specified
-// as an <offset-from-low-pc>.
+// Get the hi_pc, adding hi_pc to lo_pc when specified as an <offset-from-
+// low-pc>.
 //
 // Returns the hi_pc or fail_value.
 //----------------------------------------------------------------------
@@ -1031,8 +1030,8 @@
 //----------------------------------------------------------------------
 // GetAttributeAddressRange
 //
-// Get the lo_pc and hi_pc, adding hi_pc to lo_pc when specified
-// as an <offset-from-low-pc>.
+// Get the lo_pc and hi_pc, adding hi_pc to lo_pc when specified as an
+// <offset-from-low-pc>.
 //
 // Returns true or sets lo_pc and hi_pc to fail_value.
 //----------------------------------------------------------------------
@@ -1083,8 +1082,8 @@
 //----------------------------------------------------------------------
 // GetName
 //
-// Get value of the DW_AT_name attribute and return it if one exists,
-// else return NULL.
+// Get value of the DW_AT_name attribute and return it if one exists, else
+// return NULL.
 //----------------------------------------------------------------------
 const char *DWARFDebugInfoEntry::GetName(SymbolFileDWARF *dwarf2Data,
                                          const DWARFUnit *cu) const {
@@ -1094,8 +1093,8 @@
 //----------------------------------------------------------------------
 // GetMangledName
 //
-// Get value of the DW_AT_MIPS_linkage_name attribute and return it if
-// one exists, else return the value of the DW_AT_name attribute
+// Get value of the DW_AT_MIPS_linkage_name attribute and return it if one
+// exists, else return the value of the DW_AT_name attribute
 //----------------------------------------------------------------------
 const char *
 DWARFDebugInfoEntry::GetMangledName(SymbolFileDWARF *dwarf2Data,
@@ -1123,8 +1122,8 @@
 //----------------------------------------------------------------------
 // GetPubname
 //
-// Get value the name for a DIE as it should appear for a
-// .debug_pubnames or .debug_pubtypes section.
+// Get value the name for a DIE as it should appear for a .debug_pubnames
+// or .debug_pubtypes section.
 //----------------------------------------------------------------------
 const char *DWARFDebugInfoEntry::GetPubname(SymbolFileDWARF *dwarf2Data,
                                             const DWARFUnit *cu) const {
@@ -1152,8 +1151,8 @@
 // Get value of the DW_AT_name attribute for a debug information entry
 // that exists at offset "die_offset" and place that value into the
 // supplied stream object. If the DIE is a NULL object "NULL" is placed
-// into the stream, and if no DW_AT_name attribute exists for the DIE
-// then nothing is printed.
+// into the stream, and if no DW_AT_name attribute exists for the DIE then
+// nothing is printed.
 //----------------------------------------------------------------------
 bool DWARFDebugInfoEntry::GetName(SymbolFileDWARF *dwarf2Data,
                                   const DWARFUnit *cu,
@@ -1184,10 +1183,9 @@
 //----------------------------------------------------------------------
 // AppendTypeName
 //
-// Follows the type name definition down through all needed tags to
-// end up with a fully qualified type name and dump the results to
-// the supplied stream. This is used to show the name of types given
-// a type identifier.
+// Follows the type name definition down through all needed tags to end up
+// with a fully qualified type name and dump the results to the supplied
+// stream. This is used to show the name of types given a type identifier.
 //----------------------------------------------------------------------
 bool DWARFDebugInfoEntry::AppendTypeName(SymbolFileDWARF *dwarf2Data,
                                          const DWARFUnit *cu,
@@ -1345,8 +1343,8 @@
 //
 // This function is very similar to the BuildAddressRangeTable function
 // except that the actual DIE offset for the function is placed in the
-// table instead of the compile unit offset (which is the way the
-// standard .debug_aranges section does it).
+// table instead of the compile unit offset (which is the way the standard
+// .debug_aranges section does it).
 //----------------------------------------------------------------------
 void DWARFDebugInfoEntry::BuildFunctionAddressRangeTable(
     SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
@@ -1707,8 +1705,8 @@
             }
           }
         } else { // compile units may not have a valid high/low pc when there
-          // are address gaps in subroutines so we must always search
-          // if there is no valid high and low PC
+          // are address gaps in subroutines so we must always search if
+          // there is no valid high and low PC
           check_children = (m_tag == DW_TAG_compile_unit) &&
                            ((function_die != NULL) || (block_die != NULL));
         }
@@ -1782,9 +1780,9 @@
       const DWARFAbbreviationDeclaration *abbrev_decl =
           abbrev_set->GetAbbreviationDeclaration(m_abbr_idx);
       if (abbrev_decl) {
-        // Make sure the abbreviation code still matches. If it doesn't and
-        // the DWARF data was mmap'ed, the backing file might have been modified
-        // which is bad news.
+        // Make sure the abbreviation code still matches. If it doesn't
+        // and the DWARF data was mmap'ed, the backing file might have
+        // been modified which is bad news.
         const uint64_t abbrev_code =
             dwarf2Data->get_debug_info_data().GetULEB128(&offset);
 
Index: source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp
@@ -241,9 +241,9 @@
         default:
           log->Printf("0x%8.8x: DW_LNE_??? (%2.2x) - Skipping unknown upcode",
                       op_offset, opcode);
-          // Length doesn't include the zero opcode byte or the length itself,
-          // but
-          // it does include the sub_opcode, so we have to adjust for that below
+          // Length doesn't include the zero opcode byte or the length
+          // itself, but it does include the sub_opcode, so we have to
+          // adjust for that below
           offset += arg_size;
           break;
         }
@@ -357,9 +357,9 @@
 //----------------------------------------------------------------------
 // Parse
 //
-// Parse the entire line table contents calling callback each time a
-// new prologue is parsed and every time a new row is to be added to
-// the line table.
+// Parse the entire line table contents calling callback each time a new
+// prologue is parsed and every time a new row is to be added to the line
+// table.
 //----------------------------------------------------------------------
 void DWARFDebugLine::Parse(const DWARFDataExtractor &debug_line_data,
                            DWARFDebugLine::State::Callback callback,
@@ -472,9 +472,9 @@
 //----------------------------------------------------------------------
 // ParseStatementTable
 //
-// Parse a single line table (prologue and all rows) and call the
-// callback function once for the prologue (row in state will be zero)
-// and each time a row is to be added to the line table.
+// Parse a single line table (prologue and all rows) and call the callback
+// function once for the prologue (row in state will be zero) and each
+// time a row is to be added to the line table.
 //----------------------------------------------------------------------
 bool DWARFDebugLine::ParseStatementTable(
     const DWARFDataExtractor &debug_line_data, lldb::offset_t *offset_ptr,
@@ -511,8 +511,8 @@
     uint8_t opcode = debug_line_data.GetU8(offset_ptr);
 
     if (opcode == 0) {
-      // Extended Opcodes always start with a zero opcode followed by
-      // a uleb128 length so you can skip ones you don't know about
+      // Extended Opcodes always start with a zero opcode followed by a
+      // uleb128 length so you can skip ones you don't know about
       lldb::offset_t ext_offset = *offset_ptr;
       dw_uleb128_t len = debug_line_data.GetULEB128(offset_ptr);
       dw_offset_t arg_size = len - (*offset_ptr - ext_offset);
@@ -523,23 +523,23 @@
       case DW_LNE_end_sequence:
         // Set the end_sequence register of the state machine to true and
         // append a row to the matrix using the current values of the
-        // state-machine registers. Then reset the registers to the initial
-        // values specified above. Every statement program sequence must end
-        // with a DW_LNE_end_sequence instruction which creates a row whose
-        // address is that of the byte after the last target machine instruction
-        // of the sequence.
+        // state-machine registers. Then reset the registers to the
+        // initial values specified above. Every statement program
+        // sequence must end with a DW_LNE_end_sequence instruction which
+        // creates a row whose address is that of the byte after the last
+        // target machine instruction of the sequence.
         state.end_sequence = true;
         state.AppendRowToMatrix(*offset_ptr);
         state.Reset();
         break;
 
       case DW_LNE_set_address:
-        // Takes a single relocatable address as an operand. The size of the
-        // operand is the size appropriate to hold an address on the target
-        // machine. Set the address register to the value given by the
-        // relocatable address. All of the other statement program opcodes
-        // that affect the address register add a delta to it. This instruction
-        // stores a relocatable value into it instead.
+        // Takes a single relocatable address as an operand. The size of
+        // the operand is the size appropriate to hold an address on the
+        // target machine. Set the address register to the value given by
+        // the relocatable address. All of the other statement program
+        // opcodes that affect the address register add a delta to it.
+        // This instruction stores a relocatable value into it instead.
         if (arg_size == 4)
           state.address = debug_line_data.GetU32(offset_ptr);
         else // arg_size == 8
@@ -547,26 +547,27 @@
         break;
 
       case DW_LNE_define_file:
-        // Takes 4 arguments. The first is a null terminated string containing
-        // a source file name. The second is an unsigned LEB128 number
-        // representing
-        // the directory index of the directory in which the file was found. The
-        // third is an unsigned LEB128 number representing the time of last
-        // modification of the file. The fourth is an unsigned LEB128 number
-        // representing the length in bytes of the file. The time and length
-        // fields may contain LEB128(0) if the information is not available.
+        // Takes 4 arguments. The first is a null terminated string
+        // containing a source file name. The second is an unsigned LEB128
+        // number representing the directory index of the directory in
+        // which the file was found. The third is an unsigned LEB128
+        // number representing the time of last modification of the file.
+        // The fourth is an unsigned LEB128 number representing the length
+        // in bytes of the file. The time and length fields may contain
+        // LEB128(0) if the information is not available.
         //
-        // The directory index represents an entry in the include_directories
-        // section of the statement program prologue. The index is LEB128(0)
-        // if the file was found in the current directory of the compilation,
-        // LEB128(1) if it was found in the first directory in the
-        // include_directories section, and so on. The directory index is
-        // ignored for file names that represent full path names.
+        // The directory index represents an entry in the
+        // include_directories section of the statement program prologue.
+        // The index is LEB128(0) if the file was found in the current
+        // directory of the compilation, LEB128(1) if it was found in the
+        // first directory in the include_directories section, and so on.
+        // The directory index is ignored for file names that represent
+        // full path names.
         //
-        // The files are numbered, starting at 1, in the order in which they
-        // appear; the names in the prologue come before names defined by
-        // the DW_LNE_define_file instruction. These numbers are used in the
-        // file register of the state machine.
+        // The files are numbered, starting at 1, in the order in which
+        // they appear; the names in the prologue come before names
+        // defined by the DW_LNE_define_file instruction. These numbers
+        // are used in the file register of the state machine.
         {
           FileNameEntry fileEntry;
           fileEntry.name = debug_line_data.GetCStr(offset_ptr);
@@ -578,8 +579,9 @@
         break;
 
       default:
-        // Length doesn't include the zero opcode byte or the length itself, but
-        // it does include the sub_opcode, so we have to adjust for that below
+        // Length doesn't include the zero opcode byte or the length
+        // itself, but it does include the sub_opcode, so we have to
+        // adjust for that below
         (*offset_ptr) += arg_size;
         break;
       }
@@ -588,28 +590,28 @@
       // Standard Opcodes
       case DW_LNS_copy:
         // Takes no arguments. Append a row to the matrix using the
-        // current values of the state-machine registers. Then set
-        // the basic_block register to false.
+        // current values of the state-machine registers. Then set the
+        // basic_block register to false.
         state.AppendRowToMatrix(*offset_ptr);
         break;
 
       case DW_LNS_advance_pc:
         // Takes a single unsigned LEB128 operand, multiplies it by the
-        // min_inst_length field of the prologue, and adds the
-        // result to the address register of the state machine.
+        // min_inst_length field of the prologue, and adds the result to
+        // the address register of the state machine.
         state.address +=
             debug_line_data.GetULEB128(offset_ptr) * prologue->min_inst_length;
         break;
 
       case DW_LNS_advance_line:
-        // Takes a single signed LEB128 operand and adds that value to
-        // the line register of the state machine.
+        // Takes a single signed LEB128 operand and adds that value to the
+        // line register of the state machine.
         state.line += debug_line_data.GetSLEB128(offset_ptr);
         break;
 
       case DW_LNS_set_file:
-        // Takes a single unsigned LEB128 operand and stores it in the file
-        // register of the state machine.
+        // Takes a single unsigned LEB128 operand and stores it in the
+        // file register of the state machine.
         state.file = debug_line_data.GetULEB128(offset_ptr);
         break;
 
@@ -626,8 +628,8 @@
         break;
 
       case DW_LNS_set_basic_block:
-        // Takes no arguments. Set the basic_block register of the
-        // state machine to true
+        // Takes no arguments. Set the basic_block register of the state
+        // machine to true
         state.basic_block = true;
         break;
 
@@ -636,13 +638,14 @@
         // machine the address increment value corresponding to special
         // opcode 255. The motivation for DW_LNS_const_add_pc is this:
         // when the statement program needs to advance the address by a
-        // small amount, it can use a single special opcode, which occupies
-        // a single byte. When it needs to advance the address by up to
-        // twice the range of the last special opcode, it can use
+        // small amount, it can use a single special opcode, which
+        // occupies a single byte. When it needs to advance the address by
+        // up to twice the range of the last special opcode, it can use
         // DW_LNS_const_add_pc followed by a special opcode, for a total
         // of two bytes. Only if it needs to advance the address by more
-        // than twice that range will it need to use both DW_LNS_advance_pc
-        // and a special opcode, requiring three or more bytes.
+        // than twice that range will it need to use both
+        // DW_LNS_advance_pc and a special opcode, requiring three or more
+        // bytes.
         {
           uint8_t adjust_opcode = 255 - prologue->opcode_base;
           dw_addr_t addr_offset = (adjust_opcode / prologue->line_range) *
@@ -653,26 +656,27 @@
 
       case DW_LNS_fixed_advance_pc:
         // Takes a single uhalf operand. Add to the address register of
-        // the state machine the value of the (unencoded) operand. This
-        // is the only extended opcode that takes an argument that is not
-        // a variable length number. The motivation for DW_LNS_fixed_advance_pc
-        // is this: existing assemblers cannot emit DW_LNS_advance_pc or
-        // special opcodes because they cannot encode LEB128 numbers or
-        // judge when the computation of a special opcode overflows and
-        // requires the use of DW_LNS_advance_pc. Such assemblers, however,
-        // can use DW_LNS_fixed_advance_pc instead, sacrificing compression.
+        // the state machine the value of the (unencoded) operand. This is
+        // the only extended opcode that takes an argument that is not a
+        // variable length number. The motivation for
+        // DW_LNS_fixed_advance_pc is this: existing assemblers cannot
+        // emit DW_LNS_advance_pc or special opcodes because they cannot
+        // encode LEB128 numbers or judge when the computation of a
+        // special opcode overflows and requires the use of
+        // DW_LNS_advance_pc. Such assemblers, however, can use
+        // DW_LNS_fixed_advance_pc instead, sacrificing compression.
         state.address += debug_line_data.GetU16(offset_ptr);
         break;
 
       case DW_LNS_set_prologue_end:
-        // Takes no arguments. Set the prologue_end register of the
-        // state machine to true
+        // Takes no arguments. Set the prologue_end register of the state
+        // machine to true
         state.prologue_end = true;
         break;
 
       case DW_LNS_set_epilogue_begin:
-        // Takes no arguments. Set the basic_block register of the
-        // state machine to true
+        // Takes no arguments. Set the basic_block register of the state
+        // machine to true
         state.epilogue_begin = true;
         break;
 
@@ -684,8 +688,8 @@
 
       default:
         // Handle any unknown standard opcodes here. We know the lengths
-        // of such opcodes because they are specified in the prologue
-        // as a multiple of LEB128 operands for each opcode.
+        // of such opcodes because they are specified in the prologue as a
+        // multiple of LEB128 operands for each opcode.
         {
           uint8_t i;
           assert(static_cast<size_t>(opcode - 1) <
@@ -769,8 +773,8 @@
 //----------------------------------------------------------------------
 // ParseStatementTable
 //
-// Parse a line table at offset and populate the LineTable class with
-// the prologue and all rows.
+// Parse a line table at offset and populate the LineTable class with the
+// prologue and all rows.
 //----------------------------------------------------------------------
 bool DWARFDebugLine::ParseStatementTable(
     const DWARFDataExtractor &debug_line_data, lldb::offset_t *offset_ptr,
@@ -924,8 +928,8 @@
                                                   dw_addr_t cu_high_pc) const {
   uint32_t index = UINT32_MAX;
   if (!rows.empty()) {
-    // Use the lower_bound algorithm to perform a binary search since we know
-    // that our line table data is ordered by address.
+    // Use the lower_bound algorithm to perform a binary search since we
+    // know that our line table data is ordered by address.
     DWARFDebugLine::Row row;
     row.address = address;
     Row::const_iterator begin_pos = rows.begin();
@@ -1006,12 +1010,13 @@
 }
 
 // Insert a row at the correct address if the addresses can be out of
-// order which can only happen when we are linking a line table that
-// may have had it's contents rearranged.
+// order which can only happen when we are linking a line table that may
+// have had it's contents rearranged.
 void DWARFDebugLine::Row::Insert(Row::collection &state_coll,
                                  const Row &state) {
-  // If we don't have anything yet, or if the address of the last state in our
-  // line table is less than the current one, just append the current state
+  // If we don't have anything yet, or if the address of the last state in
+  // our line table is less than the current one, just append the current
+  // state
   if (state_coll.empty() || AddressLessThan(state_coll.back(), state)) {
     state_coll.push_back(state);
   } else {
@@ -1019,13 +1024,14 @@
     pair<Row::iterator, Row::iterator> range(equal_range(
         state_coll.begin(), state_coll.end(), state, AddressLessThan));
 
-    // If the addresses are equal, we can safely replace the previous entry
-    // with the current one if the one it is replacing is an end_sequence entry.
-    // We currently always place an extra end sequence when ever we exit a valid
-    // address range for a function in case the functions get rearranged by
-    // optimizations or by order specifications. These extra end sequences will
-    // disappear by getting replaced with valid consecutive entries within a
-    // compile unit if there are no gaps.
+    // If the addresses are equal, we can safely replace the previous
+    // entry with the current one if the one it is replacing is an
+    // end_sequence entry. We currently always place an extra end sequence
+    // when ever we exit a valid address range for a function in case the
+    // functions get rearranged by optimizations or by order
+    // specifications. These extra end sequences will disappear by getting
+    // replaced with valid consecutive entries within a compile unit if
+    // there are no gaps.
     if (range.first == range.second) {
       state_coll.insert(range.first, state);
     } else {
@@ -1065,10 +1071,10 @@
 // DWARFDebugLine::State::AppendRowToMatrix
 //----------------------------------------------------------------------
 void DWARFDebugLine::State::AppendRowToMatrix(dw_offset_t offset) {
-  // Each time we are to add an entry into the line table matrix
-  // call the callback function so that someone can do something with
-  // the current state of the state machine (like build a line table
-  // or dump the line table!)
+  // Each time we are to add an entry into the line table matrix call the
+  // callback function so that someone can do something with the current
+  // state of the state machine (like build a line table or dump the line
+  // table!)
   if (log) {
     if (row == 0) {
       log->PutCString("Address            Line   Column File   ISA Flags");
Index: source/Plugins/SymbolFile/DWARF/DWARFDebugMacinfoEntry.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFDebugMacinfoEntry.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFDebugMacinfoEntry.cpp
@@ -73,7 +73,8 @@
     case DW_MACINFO_define:
     case DW_MACINFO_undef:
       // 2 operands:
-      // Arg 1: operand encodes the line number of the source line on which
+      // Arg 1: operand encodes the line number of the source line on
+      // which
       //      the relevant defining or undefining pre-processor directives
       //      appeared.
       m_line = mac_info_data.GetULEB128(offset_ptr);
Index: source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.cpp
@@ -116,9 +116,8 @@
           sym_file_dwarf->ParseDebugMacros(&new_offset)));
       break;
     default:
-      // TODO: Add support for other standard operations.
-      // TODO: Provide mechanism to hook handling of non-standard/extension
-      // operands.
+      // TODO: Add support for other standard operations. TODO: Provide
+      // mechanism to hook handling of non-standard/extension operands.
       return;
     }
     type = static_cast<llvm::dwarf::MacroEntryType>(
Index: source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.cpp
@@ -89,8 +89,8 @@
       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
+    // 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;
 
Index: source/Plugins/SymbolFile/DWARF/DWARFDeclContext.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFDeclContext.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFDeclContext.cpp
@@ -67,8 +67,8 @@
   // First compare the tags before we do expensive name compares
   for (pos = begin, rhs_pos = rhs_begin; pos != end; ++pos, ++rhs_pos) {
     if (pos->tag != rhs_pos->tag) {
-      // Check for DW_TAG_structure_type and DW_TAG_class_type as they are often
-      // used interchangeably in GCC
+      // Check for DW_TAG_structure_type and DW_TAG_class_type as they are
+      // often used interchangeably in GCC
       if (pos->tag == DW_TAG_structure_type &&
           rhs_pos->tag == DW_TAG_class_type)
         continue;
Index: source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp
@@ -169,8 +169,8 @@
   bool is_block = false;
   m_value.data = NULL;
   uint8_t ref_addr_size;
-  // Read the value for the form into value and follow and DW_FORM_indirect
-  // instances we run into
+  // Read the value for the form into value and follow and
+  // DW_FORM_indirect instances we run into
   do {
     indirect = false;
     switch (m_form) {
@@ -506,8 +506,8 @@
     cu_relative_offset = true;
     break;
 
-  // All DW_FORM_indirect attributes should be resolved prior to calling this
-  // function
+  // All DW_FORM_indirect attributes should be resolved prior to calling
+  // this function
   case DW_FORM_indirect:
     s.PutCString("DW_FORM_indirect");
     break;
Index: source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp
+++ source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp
@@ -51,8 +51,8 @@
       func_cat, "%8.8x: DWARFUnit::ExtractDIEsIfNeeded( cu_die_only = %i )",
       m_offset, cu_die_only);
 
-  // Set the offset to that of the first DIE and calculate the start of the
-  // next compilation unit header.
+  // Set the offset to that of the first DIE and calculate the start of
+  // the next compilation unit header.
   lldb::offset_t offset = GetFirstDIEOffset();
   lldb::offset_t next_cu_offset = GetNextCompileUnitOffset();
 
@@ -71,8 +71,8 @@
   }
 
   uint32_t depth = 0;
-  // We are in our compile unit, parse starting at the offset
-  // we were told to parse
+  // We are in our compile unit, parse starting at the offset we were told
+  // to parse
   const DWARFDataExtractor &debug_info_data = m_dwarf->get_debug_info_data();
   std::vector<uint32_t> die_index_stack;
   die_index_stack.reserve(32);
@@ -105,11 +105,11 @@
     } else {
       if (null_die) {
         if (prev_die_had_children) {
-          // This will only happen if a DIE says is has children
-          // but all it contains is a NULL tag. Since we are removing
-          // the NULL DIEs from the list (saves up to 25% in C++ code),
-          // we need a way to let the DIE know that it actually doesn't
-          // have children.
+          // This will only happen if a DIE says is has children but all
+          // it contains is a NULL tag. Since we are removing the NULL
+          // DIEs from the list (saves up to 25% in C++ code), we need a
+          // way to let the DIE know that it actually doesn't have
+          // children.
           if (!m_die_array.empty())
             m_die_array.back().SetEmptyChildren(true);
         }
@@ -149,8 +149,8 @@
   }
 
   // Give a little bit of info if we encounter corrupt DWARF (our offset
-  // should always terminate at or before the start of the next compilation
-  // unit header).
+  // should always terminate at or before the start of the next
+  // compilation unit header).
   if (offset > next_cu_offset) {
     m_dwarf->GetObjectFile()->GetModule()->ReportWarning(
         "DWARF compile unit extends beyond its bounds cu 0x%8.8x at "
@@ -191,13 +191,14 @@
 void DWARFUnit::AddUnitDIE(DWARFDebugInfoEntry &die) {
   assert(m_die_array.empty() && "Compile unit DIE already added");
 
-  // The average bytes per DIE entry has been seen to be around 14-20 so lets
-  // pre-reserve half of that since we are now stripping the NULL tags.
+  // The average bytes per DIE entry has been seen to be around 14-20 so
+  // lets pre-reserve half of that since we are now stripping the NULL
+  // tags.
   
-  // Only reserve the memory if we are adding children of the main compile unit
-  // DIE. The compile unit DIE is always the first entry, so if our size is 1,
-  // then we are adding the first compile unit child DIE and should reserve
-  // the memory.
+  // Only reserve the memory if we are adding children of the main compile
+  // unit DIE. The compile unit DIE is always the first entry, so if our
+  // size is 1, then we are adding the first compile unit child DIE and
+  // should reserve the memory.
   m_die_array.reserve(GetDebugInfoSize() / 24);
   m_die_array.push_back(die);
 
@@ -236,7 +237,8 @@
   if (DIE()) {
     const DWARFDebugAranges &func_aranges = GetFunctionAranges();
 
-    // Re-check the aranges auto pointer contents in case it was created above
+    // Re-check the aranges auto pointer contents in case it was created
+    // above
     if (!func_aranges.IsEmpty())
       return GetDIE(func_aranges.FindAddress(address));
   }
@@ -309,11 +311,11 @@
   if (m_die_array.size() > 1) {
     // std::vectors never get any smaller when resized to a smaller size,
     // or when clear() or erase() are called, the size will report that it
-    // is smaller, but the memory allocated remains intact (call capacity()
-    // to see this). So we need to create a temporary vector and swap the
-    // contents which will cause just the internal pointers to be swapped
-    // so that when "tmp_array" goes out of scope, it will destroy the
-    // contents.
+    // is smaller, but the memory allocated remains intact (call
+    // capacity() to see this). So we need to create a temporary vector
+    // and swap the contents which will cause just the internal pointers
+    // to be swapped so that when "tmp_array" goes out of scope, it will
+    // destroy the contents.
 
     // Save at least the compile unit DIE
     DWARFDebugInfoEntry::collection tmp_array;
@@ -334,7 +336,8 @@
 
   size_t num_debug_aranges = debug_aranges->GetNumRanges();
 
-  // First get the compile unit DIE only and check if it has a DW_AT_ranges
+  // First get the compile unit DIE only and check if it has a
+  // DW_AT_ranges
   const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
 
   const dw_offset_t cu_offset = GetOffset();
@@ -358,10 +361,10 @@
   }
   // We don't have a DW_AT_ranges attribute, so we need to parse the DWARF
 
-  // If the DIEs weren't parsed, then we don't want all dies for all compile
-  // units
-  // to stay loaded when they weren't needed. So we can end up parsing the DWARF
-  // and then throwing them all away to keep memory usage down.
+  // If the DIEs weren't parsed, then we don't want all dies for all
+  // compile units to stay loaded when they weren't needed. So we can end
+  // up parsing the DWARF and then throwing them all away to keep memory
+  // usage down.
   const bool clear_dies = ExtractDIEsIfNeeded(false) > 1;
 
   die = DIEPtr();
@@ -370,7 +373,8 @@
 
   if (debug_aranges->GetNumRanges() == num_debug_aranges) {
     // We got nothing from the functions, maybe we have a line tables only
-    // situation. Check the line tables and build the arange table from this.
+    // situation. Check the line tables and build the arange table from
+    // this.
     SymbolContext sc;
     sc.comp_unit = dwarf->GetCompUnitForDWARFCompUnit(this);
     if (sc.comp_unit) {
@@ -398,7 +402,8 @@
 
   if (debug_aranges->GetNumRanges() == num_debug_aranges) {
     // We got nothing from the functions, maybe we have a line tables only
-    // situation. Check the line tables and build the arange table from this.
+    // situation. Check the line tables and build the arange table from
+    // this.
     SymbolContext sc;
     sc.comp_unit = dwarf->GetCompUnitForDWARFCompUnit(this);
     if (sc.comp_unit) {
@@ -419,8 +424,8 @@
     }
   }
 
-  // Keep memory down by clearing DIEs if this generate function
-  // caused them to be parsed
+  // Keep memory down by clearing DIEs if this generate function caused
+  // them to be parsed
   if (clear_dies)
     ClearDIEs(true);
 }
@@ -458,8 +463,8 @@
 //
 // Get the DIE (Debug Information Entry) with the specified offset by
 // first checking if the DIE is contained within this compile unit and
-// grabbing the DIE from this compile unit. Otherwise we grab the DIE
-// from the DWARF file.
+// grabbing the DIE from this compile unit. Otherwise we grab the DIE from
+// the DWARF file.
 //----------------------------------------------------------------------
 DWARFDIE
 DWARFUnit::GetDIE(dw_offset_t die_offset) {
@@ -477,9 +482,9 @@
           return DWARFDIE(this, &(*pos));
       }
     } else {
-      // Don't specify the compile unit offset as we don't know it because the
-      // DIE belongs to
-      // a different compile unit in the same symbol file.
+      // Don't specify the compile unit offset as we don't know it because
+      // the DIE belongs to a different compile unit in the same symbol
+      // file.
       return m_dwarf->DebugInfo()->GetDIEForDIEOffset(die_offset);
     }
   }
@@ -602,8 +607,8 @@
   return m_producer_version_update;
 }
 LanguageType DWARFUnit::LanguageTypeFromDWARF(uint64_t val) {
-  // Note: user languages between lo_user and hi_user
-  // must be handled explicitly here.
+  // Note: user languages between lo_user and hi_user must be handled
+  // explicitly here.
   switch (val) {
   case DW_LANG_Mips_Assembler:
     return eLanguageTypeMipsAssembler;
@@ -777,11 +782,11 @@
               case DW_TAG_subprogram:
               case DW_TAG_lexical_block:
               case DW_TAG_inlined_subroutine:
-                // Even if this is a function level static, we don't add it. We
-                // could theoretically add these if we wanted to by
+                // Even if this is a function level static, we don't add
+                // it. We could theoretically add these if we wanted to by
                 // introspecting into the DW_AT_location and seeing if the
-                // location describes a hard coded address, but we don't want
-                // the performance penalty of that right now.
+                // location describes a hard coded address, but we don't
+                // want the performance penalty of that right now.
                 is_global_or_static_variable = false;
                 // if (attributes.ExtractFormValueAtIndex(dwarf, i,
                 //                                        form_value)) {
@@ -850,8 +855,8 @@
               func_fullnames.Insert(objc_fullname_no_category_name,
                                     DIERef(cu_offset, die.GetOffset()));
           }
-          // If we have a mangled name, then the DW_AT_name attribute
-          // is usually the method name without the class or any parameters
+          // If we have a mangled name, then the DW_AT_name attribute is
+          // usually the method name without the class or any parameters
           const DWARFDebugInfoEntry *parent = die.GetParent();
           bool is_method = false;
           if (parent) {
@@ -883,9 +888,9 @@
         }
         if (mangled_cstr) {
           // Make sure our mangled name isn't the same string table entry
-          // as our name. If it starts with '_', then it is ok, else compare
-          // the string to make sure it isn't the same and we don't end up
-          // with duplicate entries
+          // as our name. If it starts with '_', then it is ok, else
+          // compare the string to make sure it isn't the same and we
+          // don't end up with duplicate entries
           if (name && name != mangled_cstr &&
               ((mangled_cstr[0] == '_') ||
                (::strcmp(name, mangled_cstr) != 0))) {
@@ -908,9 +913,9 @@
                                 DIERef(cu_offset, die.GetOffset()));
         if (mangled_cstr) {
           // Make sure our mangled name isn't the same string table entry
-          // as our name. If it starts with '_', then it is ok, else compare
-          // the string to make sure it isn't the same and we don't end up
-          // with duplicate entries
+          // as our name. If it starts with '_', then it is ok, else
+          // compare the string to make sure it isn't the same and we
+          // don't end up with duplicate entries
           if (name && name != mangled_cstr &&
               ((mangled_cstr[0] == '_') ||
                (::strcmp(name, mangled_cstr) != 0))) {
@@ -960,8 +965,8 @@
         // "i", a mangled named "_ZN12_GLOBAL__N_11iE" and a demangled
         // mangled name "(anonymous namespace)::i"...
 
-        // Make sure our mangled name isn't the same string table entry
-        // as our name. If it starts with '_', then it is ok, else compare
+        // Make sure our mangled name isn't the same string table entry as
+        // our name. If it starts with '_', then it is ok, else compare
         // the string to make sure it isn't the same and we don't end up
         // with duplicate entries
         if (mangled_cstr && name != mangled_cstr &&
Index: source/Plugins/SymbolFile/DWARF/HashedNameToDIE.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/HashedNameToDIE.cpp
+++ source/Plugins/SymbolFile/DWARF/HashedNameToDIE.cpp
@@ -75,15 +75,15 @@
         die_tag == DW_TAG_structure_type) {
       if (die_info_array[i].type_flags & eTypeFlagClassIsImplementation) {
         if (return_implementation_only_if_available) {
-          // We found the one true definition for this class, so
-          // only return that
+          // We found the one true definition for this class, so only
+          // return that
           die_offsets.clear();
           die_offsets.emplace_back(die_info_array[i].cu_offset,
                                    die_info_array[i].offset);
           return;
         } else {
-          // Put the one true definition as the first entry so it
-          // matches first
+          // Put the one true definition as the first entry so it matches
+          // first
           die_offsets.emplace(die_offsets.begin(), die_info_array[i].cu_offset,
                               die_info_array[i].offset);
         }
@@ -137,9 +137,9 @@
 DWARFMappedHash::Prologue::Prologue(dw_offset_t _die_base_offset)
     : die_base_offset(_die_base_offset), atoms(), atom_mask(0),
       min_hash_data_byte_size(0), hash_data_has_fixed_byte_size(true) {
-  // Define an array of DIE offsets by first defining an array,
-  // and then define the atom type for the array, in this case
-  // we have an array of DIE offsets
+  // Define an array of DIE offsets by first defining an array, and then
+  // define the atom type for the array, in this case we have an array of
+  // DIE offsets
   AppendAtom(eAtomTypeDIEOffset, DW_FORM_data4);
 }
 
@@ -238,9 +238,8 @@
 }
 
 size_t DWARFMappedHash::Prologue::GetByteSize() const {
-  // Add an extra count to the atoms size for the zero termination Atom that
-  // gets
-  // written to disk
+  // Add an extra count to the atoms size for the zero termination Atom
+  // that gets written to disk
   return sizeof(die_base_offset) + sizeof(uint32_t) +
          atoms.size() * sizeof(Atom);
 }
@@ -384,13 +383,13 @@
   pair.key = m_data.GetU32(hash_data_offset_ptr);
   pair.value.clear();
 
-  // If the key is zero, this terminates our chain of HashData objects
-  // for this hash value.
+  // If the key is zero, this terminates our chain of HashData objects for
+  // this hash value.
   if (pair.key == 0)
     return eResultEndOfHashData;
 
-  // There definitely should be a string for this string offset, if
-  // there isn't, there is something wrong, return and error
+  // There definitely should be a string for this string offset, if there
+  // isn't, there is something wrong, return and error
   const char *strp_cstr = m_string_table.PeekCStr(pair.key);
   if (strp_cstr == NULL) {
     *hash_data_offset_ptr = UINT32_MAX;
@@ -403,22 +402,21 @@
   if (count > 0 &&
       m_data.ValidOffsetForDataOfSize(*hash_data_offset_ptr,
                                       min_total_hash_data_size)) {
-    // We have at least one HashData entry, and we have enough
-    // data to parse at least "count" HashData entries.
+    // We have at least one HashData entry, and we have enough data to
+    // parse at least "count" HashData entries.
 
     // First make sure the entire C string matches...
     const bool match = name == strp_cstr;
 
     if (!match && m_header.header_data.HashDataHasFixedByteSize()) {
-      // If the string doesn't match and we have fixed size data,
-      // we can just add the total byte size of all HashData objects
-      // to the hash data offset and be done...
+      // If the string doesn't match and we have fixed size data, we can
+      // just add the total byte size of all HashData objects to the hash
+      // data offset and be done...
       *hash_data_offset_ptr += min_total_hash_data_size;
     } else {
-      // If the string does match, or we don't have fixed size data
-      // then we need to read the hash data as a stream. If the
-      // string matches we also append all HashData objects to the
-      // value array.
+      // If the string does match, or we don't have fixed size data then
+      // we need to read the hash data as a stream. If the string matches
+      // we also append all HashData objects to the value array.
       for (uint32_t i = 0; i < count; ++i) {
         DIEInfo die_info;
         if (m_header.Read(m_data, hash_data_offset_ptr, die_info)) {
@@ -432,16 +430,16 @@
         }
       }
     }
-    // Return the correct response depending on if the string matched
-    // or not...
+    // Return the correct response depending on if the string matched or
+    // not...
     if (match)
       return eResultKeyMatch; // The key (cstring) matches and we have lookup
                               // results!
     else
       return eResultKeyMismatch; // The key doesn't match, this function will
                                  // get called
-    // again for the next key/value or the key terminator
-    // which in our case is a zero .debug_str offset.
+    // again for the next key/value or the key terminator which in our
+    // case is a zero .debug_str offset.
   } else {
     *hash_data_offset_ptr = UINT32_MAX;
     return eResultError;
@@ -453,13 +451,13 @@
     const lldb_private::RegularExpression &regex,
     lldb::offset_t *hash_data_offset_ptr, Pair &pair) const {
   pair.key = m_data.GetU32(hash_data_offset_ptr);
-  // If the key is zero, this terminates our chain of HashData objects
-  // for this hash value.
+  // If the key is zero, this terminates our chain of HashData objects for
+  // this hash value.
   if (pair.key == 0)
     return eResultEndOfHashData;
 
-  // There definitely should be a string for this string offset, if
-  // there isn't, there is something wrong, return and error
+  // There definitely should be a string for this string offset, if there
+  // isn't, there is something wrong, return and error
   const char *strp_cstr = m_string_table.PeekCStr(pair.key);
   if (strp_cstr == NULL)
     return eResultError;
@@ -473,15 +471,14 @@
     const bool match = regex.Execute(llvm::StringRef(strp_cstr));
 
     if (!match && m_header.header_data.HashDataHasFixedByteSize()) {
-      // If the regex doesn't match and we have fixed size data,
-      // we can just add the total byte size of all HashData objects
-      // to the hash data offset and be done...
+      // If the regex doesn't match and we have fixed size data, we can
+      // just add the total byte size of all HashData objects to the hash
+      // data offset and be done...
       *hash_data_offset_ptr += min_total_hash_data_size;
     } else {
-      // If the string does match, or we don't have fixed size data
-      // then we need to read the hash data as a stream. If the
-      // string matches we also append all HashData objects to the
-      // value array.
+      // If the string does match, or we don't have fixed size data then
+      // we need to read the hash data as a stream. If the string matches
+      // we also append all HashData objects to the value array.
       for (uint32_t i = 0; i < count; ++i) {
         DIEInfo die_info;
         if (m_header.Read(m_data, hash_data_offset_ptr, die_info)) {
@@ -495,16 +492,16 @@
         }
       }
     }
-    // Return the correct response depending on if the string matched
-    // or not...
+    // Return the correct response depending on if the string matched or
+    // not...
     if (match)
       return eResultKeyMatch; // The key (cstring) matches and we have lookup
                               // results!
     else
       return eResultKeyMismatch; // The key doesn't match, this function will
                                  // get called
-    // again for the next key/value or the key terminator
-    // which in our case is a zero .debug_str offset.
+    // again for the next key/value or the key terminator which in our
+    // case is a zero .debug_str offset.
   } else {
     *hash_data_offset_ptr = UINT32_MAX;
     return eResultError;
@@ -529,8 +526,7 @@
       switch (hash_result) {
       case eResultKeyMatch:
       case eResultKeyMismatch:
-        // Whether we matches or not, it doesn't matter, we
-        // keep looking.
+        // Whether we matches or not, it doesn't matter, we keep looking.
         break;
 
       case eResultEndOfHashData:
@@ -610,17 +606,16 @@
   if (FindByName(name, die_info_array)) {
     if (must_be_implementation &&
         GetHeader().header_data.ContainsAtom(eAtomTypeTypeFlags)) {
-      // If we have two atoms, then we have the DIE offset and
-      // the type flags so we can find the objective C class
-      // efficiently.
+      // If we have two atoms, then we have the DIE offset and the type
+      // flags so we can find the objective C class efficiently.
       DWARFMappedHash::ExtractTypesFromDIEArray(die_info_array, UINT32_MAX,
                                                 eTypeFlagClassIsImplementation,
                                                 die_offsets);
     } else {
-      // We don't only want the one true definition, so try and see
-      // what we can find, and only return class or struct DIEs.
-      // If we do have the full implementation, then return it alone,
-      // else return all possible matches.
+      // We don't only want the one true definition, so try and see what
+      // we can find, and only return class or struct DIEs. If we do have
+      // the full implementation, then return it alone, else return all
+      // possible matches.
       const bool return_implementation_only_if_available = true;
       DWARFMappedHash::ExtractClassOrStructDIEArray(
           die_info_array, return_implementation_only_if_available, die_offsets);
Index: source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
+++ source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
@@ -93,7 +93,8 @@
 using namespace lldb_private;
 
 // static inline bool
-// child_requires_parent_class_union_or_struct_to_be_completed (dw_tag_t tag)
+// child_requires_parent_class_union_or_struct_to_be_completed (dw_tag_t
+// tag)
 //{
 //    switch (tag)
 //    {
@@ -164,8 +165,8 @@
     return path_from_dwarf;
   }
 
-  // check whether we have a windows path, and so the first character
-  // is a drive-letter not a hostname.
+  // check whether we have a windows path, and so the first character is a
+  // drive-letter not a hostname.
   if (colon_pos == path_from_dwarf + 1 && isalpha(*path_from_dwarf) &&
       strlen(path_from_dwarf) > 2 && '\\' == path_from_dwarf[2]) {
     return path_from_dwarf;
@@ -178,8 +179,8 @@
   if (!path_from_dwarf)
     return nullptr;
 
-  // DWARF2/3 suggests the form hostname:pathname for compilation directory.
-  // Remove the host part if present.
+  // DWARF2/3 suggests the form hostname:pathname for compilation
+  // directory. Remove the host part if present.
   const char *local_path = removeHostnameFromPathname(path_from_dwarf);
   if (!local_path)
     return nullptr;
@@ -502,14 +503,14 @@
       return 0;
 
     // On non Apple platforms we might have .debug_types debug info that
-    // is created by using "-fdebug-types-section". LLDB currently will try
-    // to load this debug info, but it causes crashes during debugging when
-    // types are missing since it doesn't know how to parse the info in
-    // the .debug_types type units. This causes all complex debug info
+    // is created by using "-fdebug-types-section". LLDB currently will
+    // try to load this debug info, but it causes crashes during debugging
+    // when types are missing since it doesn't know how to parse the info
+    // in the .debug_types type units. This causes all complex debug info
     // types to be unresolved. Because this causes LLDB to crash and since
     // it really doesn't provide a solid debuggiung experience, we should
-    // disable trying to debug this kind of DWARF until support gets
-    // added or deprecated.
+    // disable trying to debug this kind of DWARF until support gets added
+    // or deprecated.
     if (section_list->FindSectionByName(ConstString(".debug_types"))) {
       m_obj_file->GetModule()->ReportWarning(
         "lldb doesn’t support .debug_types debug info");
@@ -561,9 +562,9 @@
       if (symfile_dir_cstr) {
         if (strcasestr(symfile_dir_cstr, ".dsym")) {
           if (m_obj_file->GetType() == ObjectFile::eTypeDebugInfo) {
-            // We have a dSYM file that didn't have a any debug info.
-            // If the string table has a size of 1, then it was made from
-            // an executable with no debug info, or from an executable that
+            // We have a dSYM file that didn't have a any debug info. If
+            // the string table has a size of 1, then it was made from an
+            // executable with no debug info, or from an executable that
             // was stripped.
             section =
                 section_list->FindSectionByType(eSectionTypeDWARFDebugStr, true)
@@ -723,8 +724,8 @@
 
   DWARFDebugInfo *info = DebugInfo();
   if (info) {
-    // Just a normal DWARF file whose user ID for the compile unit is
-    // the DWARF offset itself
+    // Just a normal DWARF file whose user ID for the compile unit is the
+    // DWARF offset itself
 
     DWARFUnit *dwarf_cu =
         info->GetCompileUnit((dw_offset_t)comp_unit->GetID());
@@ -759,7 +760,8 @@
   if (dwarf_cu) {
     CompileUnit *comp_unit = (CompileUnit *)dwarf_cu->GetUserData();
     if (comp_unit) {
-      // We already parsed this compile unit, had out a shared pointer to it
+      // We already parsed this compile unit, had out a shared pointer to
+      // it
       cu_sp = comp_unit->shared_from_this();
     } else {
       if (dwarf_cu->GetSymbolFileDWARF() != this) {
@@ -776,10 +778,9 @@
           if (cu_die) {
             FileSpec cu_file_spec{cu_die.GetName(), false};
             if (cu_file_spec) {
-              // If we have a full path to the compile unit, we don't need to
-              // resolve
-              // the file.  This can be expensive e.g. when the source files are
-              // NFS mounted.
+              // If we have a full path to the compile unit, we don't need
+              // to resolve the file.  This can be expensive e.g. when the
+              // source files are NFS mounted.
               if (cu_file_spec.IsRelative()) {
                 const char *cu_comp_dir{
                     cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr)};
@@ -800,17 +801,15 @@
                 module_sp, dwarf_cu, cu_file_spec, dwarf_cu->GetID(),
                 cu_language, is_optimized ? eLazyBoolYes : eLazyBoolNo));
             if (cu_sp) {
-              // If we just created a compile unit with an invalid file spec,
-              // try and get the
-              // first entry in the supports files from the line table as that
-              // should be the
-              // compile unit.
+              // If we just created a compile unit with an invalid file
+              // spec, try and get the first entry in the supports files
+              // from the line table as that should be the compile unit.
               if (!cu_file_spec) {
                 cu_file_spec = cu_sp->GetSupportFiles().GetFileSpecAtIndex(1);
                 if (cu_file_spec) {
                   (FileSpec &)(*cu_sp) = cu_file_spec;
-                  // Also fix the invalid file spec which was copied from the
-                  // compile unit.
+                  // Also fix the invalid file spec which was copied from
+                  // the compile unit.
                   cu_sp->GetSupportFiles().Replace(0, cu_file_spec);
                 }
               }
@@ -917,8 +916,8 @@
       const dw_offset_t stmt_list = cu_die.GetAttributeValueAsUnsigned(
           DW_AT_stmt_list, DW_INVALID_OFFSET);
       if (stmt_list != DW_INVALID_OFFSET) {
-        // All file indexes in DWARF are one based and a file of index zero is
-        // supposed to be the compile unit itself.
+        // All file indexes in DWARF are one based and a file of index
+        // zero is supposed to be the compile unit itself.
         support_files.Append(*sc.comp_unit);
         return DWARFDebugLine::ParseSupportFiles(
             sc.comp_unit->GetModule(), get_debug_line_data(), cu_comp_dir,
@@ -998,8 +997,8 @@
         (ParseDWARFLineTableCallbackInfo *)userData;
     LineTable *line_table = info->line_table;
 
-    // If this is our first time here, we need to create a
-    // sequence container.
+    // If this is our first time here, we need to create a sequence
+    // container.
     if (!info->sequence_ap.get()) {
       info->sequence_ap.reset(line_table->CreateLineSequenceContainer());
       assert(info->sequence_ap.get());
@@ -1064,9 +1063,9 @@
           SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
           if (debug_map_symfile) {
             // We have an object file that has a line table with addresses
-            // that are not linked. We need to link the line table and convert
-            // the addresses that are relative to the .o file into addresses
-            // for the main executable.
+            // that are not linked. We need to link the line table and
+            // convert the addresses that are relative to the .o file into
+            // addresses for the main executable.
             sc.comp_unit->SetLineTable(
                 debug_map_symfile->LinkOSOLineTable(this, line_table_ap.get()));
           } else {
@@ -1142,9 +1141,9 @@
     case DW_TAG_lexical_block: {
       Block *block = NULL;
       if (tag == DW_TAG_subprogram) {
-        // Skip any DW_TAG_subprogram DIEs that are inside
-        // of a normal or inlined functions. These will be
-        // parsed on their own as separate entities.
+        // Skip any DW_TAG_subprogram DIEs that are inside of a normal or
+        // inlined functions. These will be parsed on their own as
+        // separate entities.
 
         if (depth > 0)
           break;
@@ -1172,18 +1171,15 @@
           assert(subprogram_low_pc == LLDB_INVALID_ADDRESS);
           subprogram_low_pc = ranges.GetMinRangeBase(0);
         } else if (tag == DW_TAG_inlined_subroutine) {
-          // We get called here for inlined subroutines in two ways.
-          // The first time is when we are making the Function object
-          // for this inlined concrete instance.  Since we're creating a top
-          // level block at
-          // here, the subprogram_low_pc will be LLDB_INVALID_ADDRESS.  So we
-          // need to
-          // adjust the containing address.
-          // The second time is when we are parsing the blocks inside the
-          // function that contains
-          // the inlined concrete instance.  Since these will be blocks inside
-          // the containing "real"
-          // function the offset will be for that function.
+          // We get called here for inlined subroutines in two ways. The
+          // first time is when we are making the Function object for this
+          // inlined concrete instance.  Since we're creating a top level
+          // block at here, the subprogram_low_pc will be
+          // LLDB_INVALID_ADDRESS.  So we need to adjust the containing
+          // address. The second time is when we are parsing the blocks
+          // inside the function that contains the inlined concrete
+          // instance.  Since these will be blocks inside the containing
+          // "real" function the offset will be for that function.
           if (subprogram_low_pc == LLDB_INVALID_ADDRESS) {
             subprogram_low_pc = ranges.GetMinRangeBase(0);
           }
@@ -1238,8 +1234,8 @@
       break;
     }
 
-    // Only parse siblings of the block if we are not at depth zero. A depth
-    // of zero indicates we are currently parsing the top level
+    // Only parse siblings of the block if we are not at depth zero. A
+    // depth of zero indicates we are currently parsing the top level
     // DW_TAG_subprogram DIE
 
     if (depth == 0)
@@ -1286,13 +1282,13 @@
 }
 
 SymbolFileDWARF *SymbolFileDWARF::GetDWARFForUID(lldb::user_id_t uid) {
-  // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API
-  // we must make sure we use the correct DWARF file when resolving things.
-  // On MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
-  // SymbolFileDWARF classes, one for each .o file. We can often end up
-  // with references to other DWARF objects and we must be ready to receive
-  // a "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
-  // instance.
+  // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile
+  // API we must make sure we use the correct DWARF file when resolving
+  // things. On MacOSX, when using SymbolFileDWARFDebugMap, we will use
+  // multiple SymbolFileDWARF classes, one for each .o file. We can often
+  // end up with references to other DWARF objects and we must be ready to
+  // receive a "lldb::user_id_t" that specifies a DIE from another
+  // SymbolFileDWARF instance.
   SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile();
   if (debug_map)
     return debug_map->GetSymbolFileByOSOIndex(
@@ -1302,13 +1298,13 @@
 
 DWARFDIE
 SymbolFileDWARF::GetDIEFromUID(lldb::user_id_t uid) {
-  // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API
-  // we must make sure we use the correct DWARF file when resolving things.
-  // On MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
-  // SymbolFileDWARF classes, one for each .o file. We can often end up
-  // with references to other DWARF objects and we must be ready to receive
-  // a "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
-  // instance.
+  // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile
+  // API we must make sure we use the correct DWARF file when resolving
+  // things. On MacOSX, when using SymbolFileDWARFDebugMap, we will use
+  // multiple SymbolFileDWARF classes, one for each .o file. We can often
+  // end up with references to other DWARF objects and we must be ready to
+  // receive a "lldb::user_id_t" that specifies a DIE from another
+  // SymbolFileDWARF instance.
   SymbolFileDWARF *dwarf = GetDWARFForUID(uid);
   if (dwarf)
     return dwarf->GetDIE(DIERef(uid, dwarf));
@@ -1316,9 +1312,9 @@
 }
 
 CompilerDecl SymbolFileDWARF::GetDeclForUID(lldb::user_id_t type_uid) {
-  // Anytime we have a lldb::user_id_t, we must get the DIE by
-  // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
-  // the SymbolFileDWARF::GetDIEFromUID() for details.
+  // Anytime we have a lldb::user_id_t, we must get the DIE by calling
+  // SymbolFileDWARF::GetDIEFromUID(). See comments inside the
+  // SymbolFileDWARF::GetDIEFromUID() for details.
   DWARFDIE die = GetDIEFromUID(type_uid);
   if (die)
     return die.GetDecl();
@@ -1327,9 +1323,9 @@
 
 CompilerDeclContext
 SymbolFileDWARF::GetDeclContextForUID(lldb::user_id_t type_uid) {
-  // Anytime we have a lldb::user_id_t, we must get the DIE by
-  // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
-  // the SymbolFileDWARF::GetDIEFromUID() for details.
+  // Anytime we have a lldb::user_id_t, we must get the DIE by calling
+  // SymbolFileDWARF::GetDIEFromUID(). See comments inside the
+  // SymbolFileDWARF::GetDIEFromUID() for details.
   DWARFDIE die = GetDIEFromUID(type_uid);
   if (die)
     return die.GetDeclContext();
@@ -1338,9 +1334,9 @@
 
 CompilerDeclContext
 SymbolFileDWARF::GetDeclContextContainingUID(lldb::user_id_t type_uid) {
-  // Anytime we have a lldb::user_id_t, we must get the DIE by
-  // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
-  // the SymbolFileDWARF::GetDIEFromUID() for details.
+  // Anytime we have a lldb::user_id_t, we must get the DIE by calling
+  // SymbolFileDWARF::GetDIEFromUID(). See comments inside the
+  // SymbolFileDWARF::GetDIEFromUID() for details.
   DWARFDIE die = GetDIEFromUID(type_uid);
   if (die)
     return die.GetContainingDeclContext();
@@ -1348,9 +1344,9 @@
 }
 
 Type *SymbolFileDWARF::ResolveTypeUID(lldb::user_id_t type_uid) {
-  // Anytime we have a lldb::user_id_t, we must get the DIE by
-  // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
-  // the SymbolFileDWARF::GetDIEFromUID() for details.
+  // Anytime we have a lldb::user_id_t, we must get the DIE by calling
+  // SymbolFileDWARF::GetDIEFromUID(). See comments inside the
+  // SymbolFileDWARF::GetDIEFromUID() for details.
   DWARFDIE type_die = GetDIEFromUID(type_uid);
   if (type_die)
     return type_die.ResolveType();
@@ -1371,9 +1367,9 @@
           log, "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s'",
           die.GetOffset(), die.GetTagAsCString(), die.GetName());
 
-    // We might be coming in in the middle of a type tree (a class
-    // within a class, an enum within a class), so parse any needed
-    // parent DIEs before we get to this one...
+    // We might be coming in in the middle of a type tree (a class within
+    // a class, an enum within a class), so parse any needed parent DIEs
+    // before we get to this one...
     DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(die);
     if (decl_ctx_die) {
       if (log) {
@@ -1448,12 +1444,11 @@
 
   DWARFDIE dwarf_die = GetDIE(die_it->getSecond());
   if (dwarf_die) {
-    // Once we start resolving this type, remove it from the forward declaration
-    // map in case anyone child members or other types require this type to get
-    // resolved.
-    // The type will get resolved when all of the calls to
-    // SymbolFileDWARF::ResolveClangOpaqueTypeDefinition
-    // are done.
+    // Once we start resolving this type, remove it from the forward
+    // declaration map in case anyone child members or other types require
+    // this type to get resolved. The type will get resolved when all of
+    // the calls to SymbolFileDWARF::ResolveClangOpaqueTypeDefinition are
+    // done.
     GetForwardDeclClangTypeToDie().erase(die_it);
 
     Type *type = GetDIEToType().lookup(dwarf_die.GetDIE());
@@ -1498,8 +1493,8 @@
                                              uint32_t cu_idx) {
   // Check if the symbol vendor already knows about this compile unit?
   if (dwarf_cu->GetUserData() == NULL) {
-    // The symbol vendor doesn't know about this compile unit, we
-    // need to parse and add it to the symbol vendor object.
+    // The symbol vendor doesn't know about this compile unit, we need to
+    // parse and add it to the symbol vendor object.
     return ParseCompileUnit(dwarf_cu, cu_idx).get();
   }
   return (CompileUnit *)dwarf_cu->GetUserData();
@@ -1562,9 +1557,9 @@
 std::unique_ptr<SymbolFileDWARFDwo>
 SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(
     DWARFUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die) {
-  // If we are using a dSYM file, we never want the standard DWO files since
-  // the -gmodules support uses the same DWO machanism to specify full debug
-  // info files for modules.
+  // If we are using a dSYM file, we never want the standard DWO files
+  // since the -gmodules support uses the same DWO machanism to specify
+  // full debug info files for modules.
   if (GetDebugMapSymfile())
     return nullptr;
 
@@ -1645,19 +1640,17 @@
             dwo_module_spec.GetArchitecture() =
                 m_obj_file->GetModule()->GetArchitecture();
 
-            // When LLDB loads "external" modules it looks at the
-            // presence of DW_AT_GNU_dwo_name.
-            // However, when the already created module
-            // (corresponding to .dwo itself) is being processed,
-            // it will see the presence of DW_AT_GNU_dwo_name
-            // (which contains the name of dwo file) and
-            // will try to call ModuleList::GetSharedModule again.
-            // In some cases (i.e. for empty files) Clang 4.0
-            // generates a *.dwo file which has DW_AT_GNU_dwo_name,
-            // but no DW_AT_comp_dir. In this case the method
-            // ModuleList::GetSharedModule will fail and
-            // the warning will be printed. However, as one can notice
-            // in this case we don't actually need to try to load the already
+            // When LLDB loads "external" modules it looks at the presence
+            // of DW_AT_GNU_dwo_name. However, when the already created
+            // module (corresponding to .dwo itself) is being processed,
+            // it will see the presence of DW_AT_GNU_dwo_name (which
+            // contains the name of dwo file) and will try to call
+            // ModuleList::GetSharedModule again. In some cases (i.e. for
+            // empty files) Clang 4.0 generates a *.dwo file which has
+            // DW_AT_GNU_dwo_name, but no DW_AT_comp_dir. In this case the
+            // method ModuleList::GetSharedModule will fail and the
+            // warning will be printed. However, as one can notice in this
+            // case we don't actually need to try to load the already
             // loaded module (corresponding to .dwo) so we simply skip it.
             if (m_obj_file->GetFileSpec()
                         .GetFileNameExtension()
@@ -1752,13 +1745,11 @@
       const dw_offset_t cu_offset =
           debug_info->GetCompileUnitAranges().FindAddress(file_vm_addr);
       if (cu_offset == DW_INVALID_OFFSET) {
-        // Global variables are not in the compile unit address ranges. The only
-        // way to
-        // currently find global variables is to iterate over the
-        // .debug_pubnames or the
-        // __apple_names table and find all items in there that point to
-        // DW_TAG_variable
-        // DIEs and then find the address that matches.
+        // Global variables are not in the compile unit address ranges.
+        // The only way to currently find global variables is to iterate
+        // over the .debug_pubnames or the __apple_names table and find
+        // all items in there that point to DW_TAG_variable DIEs and then
+        // find the address that matches.
         if (resolve_scope & eSymbolContextVariable) {
           GlobalVariableMap &map = GetGlobalAranges();
           const GlobalVariableMap::Entry *entry =
@@ -1797,11 +1788,11 @@
                   block_die = function_die.LookupDeepestBlock(file_vm_addr);
               } else {
                 // We might have had a compile unit that had discontiguous
-                // address ranges where the gaps are symbols that don't have
-                // any debug info. Discontiguous compile unit address ranges
-                // should only happen when there aren't other functions from
-                // other compile units in these gaps. This helps keep the size
-                // of the aranges down.
+                // address ranges where the gaps are symbols that don't
+                // have any debug info. Discontiguous compile unit address
+                // ranges should only happen when there aren't other
+                // functions from other compile units in these gaps. This
+                // helps keep the size of the aranges down.
                 force_check_line_table = true;
               }
 
@@ -1825,14 +1816,11 @@
                 force_check_line_table) {
               LineTable *line_table = sc.comp_unit->GetLineTable();
               if (line_table != NULL) {
-                // And address that makes it into this function should be in
-                // terms
-                // of this debug file if there is no debug map, or it will be an
-                // address in the .o file which needs to be fixed up to be in
-                // terms
-                // of the debug map executable. Either way, calling
-                // FixupAddress()
-                // will work for us.
+                // And address that makes it into this function should be
+                // in terms of this debug file if there is no debug map,
+                // or it will be an address in the .o file which needs to
+                // be fixed up to be in terms of the debug map executable.
+                // Either way, calling FixupAddress() will work for us.
                 Address exe_so_addr(so_addr);
                 if (FixupAddress(exe_so_addr)) {
                   if (line_table->FindLineEntryByAddress(exe_so_addr,
@@ -1849,8 +1837,8 @@
               // address ranges where the gaps are symbols that don't have
               // any debug info. Discontiguous compile unit address ranges
               // should only happen when there aren't other functions from
-              // other compile units in these gaps. This helps keep the size
-              // of the aranges down.
+              // other compile units in these gaps. This helps keep the
+              // size of the aranges down.
               sc.comp_unit = NULL;
               resolved &= ~eSymbolContextCompUnit;
             }
@@ -1905,8 +1893,8 @@
               LineTable *line_table = sc.comp_unit->GetLineTable();
 
               if (line_table != NULL && line != 0) {
-                // We will have already looked up the file index if
-                // we are searching for inline entries.
+                // We will have already looked up the file index if we are
+                // searching for inline entries.
                 if (!check_inlines)
                   file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex(
                       1, file_spec, true);
@@ -1962,17 +1950,15 @@
                   }
                 }
               } else if (file_spec_matches_cu_file_spec && !check_inlines) {
-                // only append the context if we aren't looking for inline call
-                // sites
-                // by file and line and if the file spec matches that of the
-                // compile unit
+                // only append the context if we aren't looking for inline
+                // call sites by file and line and if the file spec
+                // matches that of the compile unit
                 sc_list.Append(sc);
               }
             } else if (file_spec_matches_cu_file_spec && !check_inlines) {
-              // only append the context if we aren't looking for inline call
-              // sites
-              // by file and line and if the file spec matches that of the
-              // compile unit
+              // only append the context if we aren't looking for inline
+              // call sites by file and line and if the file spec matches
+              // that of the compile unit
               sc_list.Append(sc);
             }
 
@@ -2016,8 +2002,8 @@
     std::vector<NameToDIE> type_index(num_compile_units);
     std::vector<NameToDIE> namespace_index(num_compile_units);
 
-    // std::vector<bool> might be implemented using bit test-and-set, so use
-    // uint8_t instead.
+    // std::vector<bool> might be implemented using bit test-and-set, so
+    // use uint8_t instead.
     std::vector<uint8_t> clear_cu_dies(num_compile_units, false);
     auto parser_fn = [debug_info, &function_basename_index,
                       &function_fullname_index, &function_method_index,
@@ -2044,22 +2030,21 @@
       }
     };
 
-    // Create a task runner that extracts dies for each DWARF compile unit in a
-    // separate thread
+    // Create a task runner that extracts dies for each DWARF compile unit
+    // in a separate thread
     //----------------------------------------------------------------------
     // First figure out which compile units didn't have their DIEs already
-    // parsed and remember this.  If no DIEs were parsed prior to this index
-    // function call, we are going to want to clear the CU dies after we
-    // are done indexing to make sure we don't pull in all DWARF dies, but
-    // we need to wait until all compile units have been indexed in case
-    // a DIE in one compile unit refers to another and the indexes accesses
-    // those DIEs.
+    // parsed and remember this.  If no DIEs were parsed prior to this
+    // index function call, we are going to want to clear the CU dies
+    // after we are done indexing to make sure we don't pull in all DWARF
+    // dies, but we need to wait until all compile units have been indexed
+    // in case a DIE in one compile unit refers to another and the indexes
+    // accesses those DIEs.
     //----------------------------------------------------------------------
     TaskMapOverInt(0, num_compile_units, extract_fn);
 
-    // Now create a task runner that can index each DWARF compile unit in a
-    // separate
-    // thread so we can index quickly.
+    // Now create a task runner that can index each DWARF compile unit in
+    // a separate thread so we can index quickly.
 
     TaskMapOverInt(0, num_compile_units, parser_fn);
 
@@ -2435,10 +2420,9 @@
 
 bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext *decl_ctx,
                                        const DWARFDIE &die) {
-  // If we have no parent decl context to match this DIE matches, and if the
-  // parent
-  // decl context isn't valid, we aren't trying to look for any particular decl
-  // context so any die matches.
+  // If we have no parent decl context to match this DIE matches, and if
+  // the parent decl context isn't valid, we aren't trying to look for any
+  // particular decl context so any die matches.
   if (decl_ctx == nullptr || !decl_ctx->IsValid())
     return true;
 
@@ -2487,8 +2471,8 @@
   if (name.IsEmpty())
     return 0;
 
-  // Remember how many sc_list are in the list before we search in case
-  // we are appending the results to a variable list.
+  // Remember how many sc_list are in the list before we search in case we
+  // are appending the results to a variable list.
 
   const uint32_t original_size = sc_list.GetSize();
 
@@ -2505,11 +2489,10 @@
       uint32_t num_matches = 0;
 
       if (name_type_mask & eFunctionNameTypeFull) {
-        // If they asked for the full name, match what they typed.  At some
-        // point we may
-        // want to canonicalize this (strip double spaces, etc.  For now, we
-        // just add all the
-        // dies that we find by exact match.
+        // If they asked for the full name, match what they typed.  At
+        // some point we may want to canonicalize this (strip double
+        // spaces, etc.  For now, we just add all the dies that we find by
+        // exact match.
         num_matches =
             m_apple_names_ap->FindByName(name.GetStringRef(), die_offsets);
         for (uint32_t i = 0; i < num_matches; i++) {
@@ -2538,9 +2521,9 @@
 
         num_matches =
             m_apple_names_ap->FindByName(name.GetStringRef(), die_offsets);
-        // Now make sure these are actually ObjC methods.  In this case we can
-        // simply look up the name,
-        // and if it is an ObjC method name, we're good.
+        // Now make sure these are actually ObjC methods.  In this case we
+        // can simply look up the name, and if it is an ObjC method name,
+        // we're good.
 
         for (uint32_t i = 0; i < num_matches; i++) {
           const DIERef &die_ref = die_offsets[i];
@@ -2565,14 +2548,13 @@
 
       if (((name_type_mask & eFunctionNameTypeMethod) && !parent_decl_ctx) ||
           name_type_mask & eFunctionNameTypeBase) {
-        // The apple_names table stores just the "base name" of C++ methods in
-        // the table.  So we have to
-        // extract the base name, look that up, and if there is any other
-        // information in the name we were
-        // passed in we have to post-filter based on that.
-
-        // FIXME: Arrange the logic above so that we don't calculate the base
-        // name twice:
+        // The apple_names table stores just the "base name" of C++
+        // methods in the table.  So we have to extract the base name,
+        // look that up, and if there is any other information in the name
+        // we were passed in we have to post-filter based on that.
+
+        // FIXME: Arrange the logic above so that we don't calculate the
+        // base name twice:
         num_matches =
             m_apple_names_ap->FindByName(name.GetStringRef(), die_offsets);
 
@@ -2590,8 +2572,9 @@
               if ((name_type_mask &
                    (eFunctionNameTypeBase | eFunctionNameTypeMethod)) !=
                   (eFunctionNameTypeBase | eFunctionNameTypeMethod)) {
-                // We are looking for either basenames or methods, so we need to
-                // trim out the ones we won't want by looking at the type
+                // We are looking for either basenames or methods, so we
+                // need to trim out the ones we won't want by looking at
+                // the type
                 SymbolContext sc;
                 if (sc_list.GetLastContext(sc)) {
                   if (sc.block) {
@@ -2644,14 +2627,13 @@
       FindFunctions(name, m_function_fullname_index, include_inlines, sc_list);
 
       // FIXME Temporary workaround for global/anonymous namespace
-      // functions debugging FreeBSD and Linux binaries.
-      // If we didn't find any functions in the global namespace try
-      // looking in the basename index but ignore any returned
-      // functions that have a namespace but keep functions which
-      // have an anonymous namespace
-      // TODO: The arch in the object file isn't correct for MSVC
-      // binaries on windows, we should find a way to make it
-      // correct and handle those symbols as well.
+      // functions debugging FreeBSD and Linux binaries. If we didn't find
+      // any functions in the global namespace try looking in the basename
+      // index but ignore any returned functions that have a namespace but
+      // keep functions which have an anonymous namespace TODO: The arch
+      // in the object file isn't correct for MSVC binaries on windows, we
+      // should find a way to make it correct and handle those symbols as
+      // well.
       if (sc_list.GetSize() == original_size) {
         ArchSpec arch;
         if (!parent_decl_ctx && GetObjectFile()->GetArchitecture(arch) &&
@@ -2757,8 +2739,8 @@
   if (!append)
     sc_list.Clear();
 
-  // Remember how many sc_list are in the list before we search in case
-  // we are appending the results to a variable list.
+  // Remember how many sc_list are in the list before we search in case we
+  // are appending the results to a variable list.
   uint32_t original_size = sc_list.GetSize();
 
   if (m_using_apple_tables) {
@@ -2875,8 +2857,8 @@
 
         Type *matching_type = ResolveType(die, true, true);
         if (matching_type) {
-          // We found a type pointer, now find the shared pointer form our type
-          // list
+          // We found a type pointer, now find the shared pointer form our
+          // type list
           types.InsertUnique(matching_type->shared_from_this());
           if (types.GetSize() >= max_matches)
             break;
@@ -2970,8 +2952,8 @@
 
         Type *matching_type = ResolveType(die, true, true);
         if (matching_type) {
-          // We found a type pointer, now find the shared pointer form our type
-          // list
+          // We found a type pointer, now find the shared pointer form our
+          // type list
           types.InsertUnique(matching_type->shared_from_this());
           ++num_matches;
         }
@@ -3009,8 +2991,8 @@
   if (info) {
     DIEArray die_offsets;
 
-    // Index if we already haven't to make sure the compile units
-    // get indexed and make their global DIE index list
+    // Index if we already haven't to make sure the compile units get
+    // indexed and make their global DIE index list
     if (m_using_apple_tables) {
       if (m_apple_namespaces_ap.get()) {
         m_apple_namespaces_ap->FindByName(name.GetStringRef(), die_offsets);
@@ -3098,9 +3080,9 @@
     DWARFDIE die = orig_die;
 
     while (die) {
-      // If this is the original DIE that we are searching for a declaration
-      // for, then don't look in the cache as we don't want our own decl
-      // context to be our decl context...
+      // If this is the original DIE that we are searching for a
+      // declaration for, then don't look in the cache as we don't want
+      // our own decl context to be our decl context...
       if (orig_die != die) {
         switch (die.Tag()) {
         case DW_TAG_compile_unit:
@@ -3157,15 +3139,12 @@
   return objc_class_symbol;
 }
 
-// Some compilers don't emit the DW_AT_APPLE_objc_complete_type attribute. If
-// they don't
-// then we can end up looking through all class types for a complete type and
-// never find
-// the full definition. We need to know if this attribute is supported, so we
-// determine
-// this here and cache th result. We also need to worry about the debug map
-// DWARF file
-// if we are doing darwin DWARF in .o file debugging.
+// Some compilers don't emit the DW_AT_APPLE_objc_complete_type attribute.
+// If they don't then we can end up looking through all class types for a
+// complete type and never find the full definition. We need to know if
+// this attribute is supported, so we determine this here and cache th
+// result. We also need to worry about the debug map DWARF file if we are
+// doing darwin DWARF in .o file debugging.
 bool SymbolFileDWARF::Supports_DW_AT_APPLE_objc_complete_type(
     DWARFUnit *cu) {
   if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate) {
@@ -3191,8 +3170,9 @@
   return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes;
 }
 
-// This function can be used when a DIE is found that is a forward declaration
-// DIE and we want to try and find a type that has the complete definition.
+// This function can be used when a DIE is found that is a forward
+// declaration DIE and we want to try and find a type that has the
+// complete definition.
 TypeSP SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE(
     const DWARFDIE &die, const ConstString &type_name,
     bool must_be_implementation) {
@@ -3226,7 +3206,8 @@
       if (type_die) {
         bool try_resolving_type = false;
 
-        // Don't try and resolve the DIE we are looking for with the DIE itself!
+        // Don't try and resolve the DIE we are looking for with the DIE
+        // itself!
         if (type_die != die) {
           switch (type_die.Tag()) {
           case DW_TAG_class_type:
@@ -3281,10 +3262,10 @@
 // There will often be a declaration of that type elsewhere that has the
 // full definition. When we go looking for the full type "my_struct", we
 // will find one or more matches in the accelerator tables and we will
-// then need to make sure the type was in the same declaration context
-// as the original DIE. This function can efficiently compare two DIEs
-// and will return true when the declaration context matches, and false
-// when they don't.
+// then need to make sure the type was in the same declaration context as
+// the original DIE. This function can efficiently compare two DIEs and
+// will return true when the declaration context matches, and false when
+// they don't.
 //----------------------------------------------------------------------
 bool SymbolFileDWARF::DIEDeclContextsMatch(const DWARFDIE &die1,
                                            const DWARFDIE &die2) {
@@ -3293,32 +3274,32 @@
 
   DWARFDIECollection decl_ctx_1;
   DWARFDIECollection decl_ctx_2;
-  // The declaration DIE stack is a stack of the declaration context
-  // DIEs all the way back to the compile unit. If a type "T" is
-  // declared inside a class "B", and class "B" is declared inside
-  // a class "A" and class "A" is in a namespace "lldb", and the
-  // namespace is in a compile unit, there will be a stack of DIEs:
+  // The declaration DIE stack is a stack of the declaration context DIEs
+  // all the way back to the compile unit. If a type "T" is declared
+  // inside a class "B", and class "B" is declared inside a class "A" and
+  // class "A" is in a namespace "lldb", and the namespace is in a compile
+  // unit, there will be a stack of DIEs:
   //
   //   [0] DW_TAG_class_type for "B"
   //   [1] DW_TAG_class_type for "A"
   //   [2] DW_TAG_namespace  for "lldb"
   //   [3] DW_TAG_compile_unit for the source file.
   //
-  // We grab both contexts and make sure that everything matches
-  // all the way back to the compiler unit.
+  // We grab both contexts and make sure that everything matches all the
+  // way back to the compiler unit.
 
   // First lets grab the decl contexts for both DIEs
   die1.GetDeclContextDIEs(decl_ctx_1);
   die2.GetDeclContextDIEs(decl_ctx_2);
-  // Make sure the context arrays have the same size, otherwise
-  // we are done
+  // Make sure the context arrays have the same size, otherwise we are
+  // done
   const size_t count1 = decl_ctx_1.Size();
   const size_t count2 = decl_ctx_2.Size();
   if (count1 != count2)
     return false;
 
-  // Make sure the DW_TAG values match all the way back up the
-  // compile unit. If they don't, then we are done.
+  // Make sure the DW_TAG values match all the way back up the compile
+  // unit. If they don't, then we are done.
   DWARFDIE decl_ctx_die1;
   DWARFDIE decl_ctx_die2;
   size_t i;
@@ -3331,8 +3312,8 @@
 #if defined LLDB_CONFIGURATION_DEBUG
 
   // Make sure the top item in the decl context die array is always
-  // DW_TAG_compile_unit. If it isn't then something went wrong in
-  // the DWARFDIE::GetDeclContextDIEs() function...
+  // DW_TAG_compile_unit. If it isn't then something went wrong in the
+  // DWARFDIE::GetDeclContextDIEs() function...
   assert(decl_ctx_1.GetDIEAtIndex(count1 - 1).Tag() == DW_TAG_compile_unit);
 
 #endif
@@ -3348,8 +3329,8 @@
     if (name1 == name2)
       continue;
 
-    // Name pointers are not equal, so only compare the strings
-    // if both are not NULL.
+    // Name pointers are not equal, so only compare the strings if both
+    // are not NULL.
     if (name1 && name2) {
       // If the strings don't compare, we are done...
       if (strcmp(name1, name2) != 0)
@@ -3359,8 +3340,8 @@
       return false;
     }
   }
-  // We made it through all of the checks and the declaration contexts
-  // are equal.
+  // We made it through all of the checks and the declaration contexts are
+  // equal.
   return true;
 }
 
@@ -3422,10 +3403,9 @@
 
       const size_t num_matches = die_offsets.size();
 
-      // Get the type system that we are looking to find a type for. We will use
-      // this
-      // to ensure any matches we find are in a language that this type system
-      // supports
+      // Get the type system that we are looking to find a type for. We
+      // will use this to ensure any matches we find are in a language
+      // that this type system supports
       const LanguageType language = dwarf_decl_ctx.GetLanguage();
       TypeSystem *type_system = (language == eLanguageTypeUnknown)
                                     ? nullptr
@@ -3437,18 +3417,17 @@
           DWARFDIE type_die = GetDIE(die_ref);
 
           if (type_die) {
-            // Make sure type_die's langauge matches the type system we are
-            // looking for.
-            // We don't want to find a "Foo" type from Java if we are looking
-            // for a "Foo"
-            // type for C, C++, ObjC, or ObjC++.
+            // Make sure type_die's langauge matches the type system we
+            // are looking for. We don't want to find a "Foo" type from
+            // Java if we are looking for a "Foo" type for C, C++, ObjC,
+            // or ObjC++.
             if (type_system &&
                 !type_system->SupportsLanguage(type_die.GetLanguage()))
               continue;
             bool try_resolving_type = false;
 
-            // Don't try and resolve the DIE we are looking for with the DIE
-            // itself!
+            // Don't try and resolve the DIE we are looking for with the
+            // DIE itself!
             const dw_tag_t type_tag = type_die.Tag();
             // Make sure the tags match
             if (type_tag == tag) {
@@ -3456,23 +3435,22 @@
               try_resolving_type = true;
             } else {
               // The tags don't match, but we need to watch our for a
-              // forward declaration for a struct and ("struct foo")
-              // ends up being a class ("class foo { ... };") or
-              // vice versa.
+              // forward declaration for a struct and ("struct foo") ends
+              // up being a class ("class foo { ... };") or vice versa.
               switch (type_tag) {
               case DW_TAG_class_type:
-                // We had a "class foo", see if we ended up with a "struct foo {
-                // ... };"
+                // We had a "class foo", see if we ended up with a "struct
+                // foo { ... };"
                 try_resolving_type = (tag == DW_TAG_structure_type);
                 break;
               case DW_TAG_structure_type:
-                // We had a "struct foo", see if we ended up with a "class foo {
-                // ... };"
+                // We had a "struct foo", see if we ended up with a "class
+                // foo { ... };"
                 try_resolving_type = (tag == DW_TAG_class_type);
                 break;
               default:
-                // Tags don't match, don't event try to resolve
-                // using this type whose name matches....
+                // Tags don't match, don't event try to resolve using this
+                // type whose name matches....
                 break;
               }
             }
@@ -3788,12 +3766,12 @@
             is_external = form_value.Boolean();
             break;
           case DW_AT_const_value:
-            // If we have already found a DW_AT_location attribute, ignore this
-            // attribute.
+            // If we have already found a DW_AT_location attribute, ignore
+            // this attribute.
             if (!has_explicit_location) {
               location_is_const_value_data = true;
-              // The constant value will be either a block, a data value or a
-              // string.
+              // The constant value will be either a block, a data value
+              // or a string.
               const DWARFDataExtractor &debug_info_data = get_debug_info_data();
               if (DWARFFormValue::IsBlockForm(form_value.Form())) {
                 // Retrieve the value as a block expression.
@@ -3816,8 +3794,8 @@
                   if (data_pointer) {
                     form_value.Unsigned();
                   } else if (DWARFFormValue::IsDataForm(form_value.Form())) {
-                    // we need to get the byte size of the type later after we
-                    // create the variable
+                    // we need to get the byte size of the type later
+                    // after we create the variable
                     const_value = form_value;
                   }
                 } else
@@ -3885,9 +3863,9 @@
                                        form_value.Unsigned(),
                                        dwarf_scope_ranges);
 
-              // All DW_AT_start_scope are relative to the base address of the
-              // compile unit. We add the compile unit base address to make
-              // sure all the addresses are properly fixed up.
+              // All DW_AT_start_scope are relative to the base address of
+              // the compile unit. We add the compile unit base address to
+              // make sure all the addresses are properly fixed up.
               for (size_t i = 0, count = dwarf_scope_ranges.GetSize();
                    i < count; ++i) {
                 const DWARFRangeList::Entry &range =
@@ -3898,12 +3876,10 @@
               }
             } else {
               // TODO: Handle the case when DW_AT_start_scope have form
-              // constant. The
-              // dwarf spec is a bit ambiguous about what is the expected
-              // behavior in
-              // case the enclosing block have a non coninious address range and
-              // the
-              // DW_AT_start_scope entry have a form constant.
+              // constant. The dwarf spec is a bit ambiguous about what is
+              // the expected behavior in case the enclosing block have a
+              // non coninious address range and the DW_AT_start_scope
+              // entry have a form constant.
               GetObjectFile()->GetModule()->ReportWarning(
                   "0x%8.8" PRIx64
                   ": DW_AT_start_scope has unsupported form type (0x%x)\n",
@@ -3918,7 +3894,8 @@
             break;
           case DW_AT_accessibility:
             break; // accessibility =
-                   // DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
+                   // DW_ACCESS_to_AccessType(form_value.Unsigned());
+                   // break;
           case DW_AT_declaration:
           case DW_AT_description:
           case DW_AT_endianity:
@@ -3947,16 +3924,13 @@
       bool has_explicit_mangled = mangled != nullptr;
       if (!mangled) {
         // LLDB relies on the mangled name (DW_TAG_linkage_name or
-        // DW_AT_MIPS_linkage_name) to
-        // generate fully qualified names of global variables with commands like
-        // "frame var j".
-        // For example, if j were an int variable holding a value 4 and declared
-        // in a namespace
-        // B which in turn is contained in a namespace A, the command "frame var
-        // j" returns
-        // "(int) A::B::j = 4". If the compiler does not emit a linkage name, we
-        // should be able
-        // to generate a fully qualified name from the declaration context.
+        // DW_AT_MIPS_linkage_name) to generate fully qualified names of
+        // global variables with commands like "frame var j". For example,
+        // if j were an int variable holding a value 4 and declared in a
+        // namespace B which in turn is contained in a namespace A, the
+        // command "frame var j" returns "(int) A::B::j = 4". If the
+        // compiler does not emit a linkage name, we should be able to
+        // generate a fully qualified name from the declaration context.
         if (parent_tag == DW_TAG_compile_unit &&
             Language::LanguageIsCPlusPlus(die.GetLanguage())) {
           DWARFDeclContext decl_ctx;
@@ -3970,17 +3944,19 @@
         scope = eValueTypeVariableArgument;
       else {
         // DWARF doesn't specify if a DW_TAG_variable is a local, global
-        // or static variable, so we have to do a little digging:
-        // 1) DW_AT_linkage_name implies static lifetime (but may be missing)
-        // 2) An empty DW_AT_location is an (optimized-out) static lifetime var.
-        // 3) DW_AT_location containing a DW_OP_addr implies static lifetime.
-        // Clang likes to combine small global variables into the same symbol
-        // with locations like: DW_OP_addr(0x1000), DW_OP_constu(2), DW_OP_plus
-        // so we need to look through the whole expression.
+        // or static variable, so we have to do a little digging: 1)
+        // DW_AT_linkage_name implies static lifetime (but may be missing)
+        // 2) An empty DW_AT_location is an (optimized-out) static
+        // lifetime var. 3) DW_AT_location containing a DW_OP_addr implies
+        // static lifetime. Clang likes to combine small global variables
+        // into the same symbol with locations like: DW_OP_addr(0x1000),
+        // DW_OP_constu(2), DW_OP_plus so we need to look through the
+        // whole expression.
         bool is_static_lifetime =
             has_explicit_mangled ||
             (has_explicit_location && !location.IsValid());
-        // Check if the location has a DW_OP_addr with any address value...
+        // Check if the location has a DW_OP_addr with any address
+        // value...
         lldb::addr_t location_DW_OP_addr = LLDB_INVALID_ADDRESS;
         if (!location_is_const_value_data) {
           bool op_error = false;
@@ -4005,24 +3981,22 @@
             scope = eValueTypeVariableStatic;
 
           if (debug_map_symfile) {
-            // When leaving the DWARF in the .o files on darwin,
-            // when we have a global variable that wasn't initialized,
-            // the .o file might not have allocated a virtual
-            // address for the global variable. In this case it will
-            // have created a symbol for the global variable
-            // that is undefined/data and external and the value will
-            // be the byte size of the variable. When we do the
-            // address map in SymbolFileDWARFDebugMap we rely on
-            // having an address, we need to do some magic here
-            // so we can get the correct address for our global
-            // variable. The address for all of these entries
-            // will be zero, and there will be an undefined symbol
-            // in this object file, and the executable will have
-            // a matching symbol with a good address. So here we
-            // dig up the correct address and replace it in the
-            // location for the variable, and set the variable's
-            // symbol context scope to be that of the main executable
-            // so the file address will resolve correctly.
+            // When leaving the DWARF in the .o files on darwin, when we
+            // have a global variable that wasn't initialized, the .o file
+            // might not have allocated a virtual address for the global
+            // variable. In this case it will have created a symbol for
+            // the global variable that is undefined/data and external and
+            // the value will be the byte size of the variable. When we do
+            // the address map in SymbolFileDWARFDebugMap we rely on
+            // having an address, we need to do some magic here so we can
+            // get the correct address for our global variable. The
+            // address for all of these entries will be zero, and there
+            // will be an undefined symbol in this object file, and the
+            // executable will have a matching symbol with a good address.
+            // So here we dig up the correct address and replace it in the
+            // location for the variable, and set the variable's symbol
+            // context scope to be that of the main executable so the file
+            // address will resolve correctly.
             bool linked_oso_file_addr = false;
             if (is_external && location_DW_OP_addr == 0) {
               // we have a possible uninitialized extern global
@@ -4053,9 +4027,8 @@
             }
 
             if (!linked_oso_file_addr) {
-              // The DW_OP_addr is not zero, but it contains a .o file address
-              // which
-              // needs to be linked up correctly.
+              // The DW_OP_addr is not zero, but it contains a .o file
+              // address which needs to be linked up correctly.
               const lldb::addr_t exe_file_addr =
                   debug_map_symfile->LinkOSOFileAddress(this,
                                                         location_DW_OP_addr);
@@ -4125,16 +4098,16 @@
 
         var_sp->SetLocationIsConstantValueData(location_is_const_value_data);
       } else {
-        // Not ready to parse this variable yet. It might be a global
-        // or static variable that is in a function scope and the function
-        // in the symbol context wasn't filled in yet
+        // Not ready to parse this variable yet. It might be a global or
+        // static variable that is in a function scope and the function in
+        // the symbol context wasn't filled in yet
         return var_sp;
       }
     }
     // Cache var_sp even if NULL (the variable was just a specification or
-    // was missing vital information to be able to be displayed in the debugger
-    // (missing location due to optimization, etc)) so we don't re-parse
-    // this DIE over and over later...
+    // was missing vital information to be able to be displayed in the
+    // debugger (missing location due to optimization, etc)) so we don't
+    // re-parse this DIE over and over later...
     GetDIEToVariable()[die.GetDIE()] = var_sp;
     if (spec_die)
       GetDIEToVariable()[spec_die.GetDIE()] = var_sp;
@@ -4145,9 +4118,9 @@
 DWARFDIE
 SymbolFileDWARF::FindBlockContainingSpecification(
     const DIERef &func_die_ref, dw_offset_t spec_block_die_offset) {
-  // Give the concrete function die specified by "func_die_offset", find the
-  // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
-  // to "spec_block_die_offset"
+  // Give the concrete function die specified by "func_die_offset", find
+  // the concrete block whose DW_AT_specification or DW_AT_abstract_origin
+  // points to "spec_block_die_offset"
   return FindBlockContainingSpecification(DebugInfo()->GetDIE(func_die_ref),
                                           spec_block_die_offset);
 }
@@ -4171,9 +4144,9 @@
     } break;
     }
 
-    // Give the concrete function die specified by "func_die_offset", find the
-    // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
-    // to "spec_block_die_offset"
+    // Give the concrete function die specified by "func_die_offset", find
+    // the concrete block whose DW_AT_specification or
+    // DW_AT_abstract_origin points to "spec_block_die_offset"
     for (DWARFDIE child_die = die.GetFirstChild(); child_die;
          child_die = child_die.GetSibling()) {
       DWARFDIE result_die =
@@ -4235,16 +4208,16 @@
           case DW_TAG_inlined_subroutine:
           case DW_TAG_lexical_block:
             if (sc.function != NULL) {
-              // Check to see if we already have parsed the variables for the
-              // given scope
+              // Check to see if we already have parsed the variables for
+              // the given scope
 
               Block *block = sc.function->GetBlock(true).FindBlockByID(
                   sc_parent_die.GetID());
               if (block == NULL) {
-                // This must be a specification or abstract origin with
-                // a concrete block counterpart in the current function. We need
-                // to find the concrete block so we can correctly add the
-                // variable to it
+                // This must be a specification or abstract origin with a
+                // concrete block counterpart in the current function. We
+                // need to find the concrete block so we can correctly add
+                // the variable to it
                 const DWARFDIE concrete_block_die =
                     FindBlockContainingSpecification(
                         DIERef(sc.function->GetID(), this),
Index: source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp
+++ source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp
@@ -44,10 +44,9 @@
 using namespace lldb_private;
 
 // Subclass lldb_private::Module so we can intercept the
-// "Module::GetObjectFile()"
-// (so we can fixup the object file sections) and also for
-// "Module::GetSymbolVendor()"
-// (so we can fixup the symbol file id.
+// "Module::GetObjectFile()" (so we can fixup the object file sections)
+// and also for "Module::GetSymbolVendor()" (so we can fixup the symbol
+// file id.
 
 const SymbolFileDWARFDebugMap::FileRangeMap &
 SymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap(
@@ -83,9 +82,9 @@
 
       /// const uint32_t fun_resolve_flags = SymbolContext::Module |
       /// eSymbolContextCompUnit | eSymbolContextFunction;
-      // SectionList *oso_sections = oso_objfile->Sections();
-      // Now we need to make sections that map from zero based object
-      // file addresses to where things ended up in the main executable.
+      // SectionList *oso_sections = oso_objfile->Sections(); Now we need
+      // to make sections that map from zero based object file addresses
+      // to where things ended up in the main executable.
 
       assert(comp_unit_info->first_symbol_index != UINT32_MAX);
       // End index is one past the last valid symbol index
@@ -104,22 +103,25 @@
             break;
 
           case eSymbolTypeCode: {
-            // For each N_FUN, or function that we run into in the debug map
-            // we make a new section that we add to the sections found in the
-            // .o file. This new section has the file address set to what the
-            // addresses are in the .o file, and the load address is adjusted
-            // to match where it ended up in the final executable! We do this
-            // before we parse any dwarf info so that when it goes get parsed
-            // all section/offset addresses that get registered will resolve
-            // correctly to the new addresses in the main executable.
-
-            // First we find the original symbol in the .o file's symbol table
+            // For each N_FUN, or function that we run into in the debug
+            // map we make a new section that we add to the sections found
+            // in the .o file. This new section has the file address set
+            // to what the addresses are in the .o file, and the load
+            // address is adjusted to match where it ended up in the final
+            // executable! We do this before we parse any dwarf info so
+            // that when it goes get parsed all section/offset addresses
+            // that get registered will resolve correctly to the new
+            // addresses in the main executable.
+
+            // First we find the original symbol in the .o file's symbol
+            // table
             Symbol *oso_fun_symbol = oso_symtab->FindFirstSymbolWithNameAndType(
                 exe_symbol->GetMangled().GetName(lldb::eLanguageTypeUnknown,
                                                  Mangled::ePreferMangled),
                 eSymbolTypeCode, Symtab::eDebugNo, Symtab::eVisibilityAny);
             if (oso_fun_symbol) {
-              // Add the inverse OSO file address to debug map entry mapping
+              // Add the inverse OSO file address to debug map entry
+              // mapping
               exe_symfile->AddOSOFileRange(
                   this, exe_symbol->GetAddressRef().GetFileAddress(),
                   exe_symbol->GetByteSize(),
@@ -129,21 +131,22 @@
           } break;
 
           case eSymbolTypeData: {
-            // For each N_GSYM we remap the address for the global by making
-            // a new section that we add to the sections found in the .o file.
-            // This new section has the file address set to what the
-            // addresses are in the .o file, and the load address is adjusted
-            // to match where it ended up in the final executable! We do this
-            // before we parse any dwarf info so that when it goes get parsed
-            // all section/offset addresses that get registered will resolve
-            // correctly to the new addresses in the main executable. We
-            // initially set the section size to be 1 byte, but will need to
-            // fix up these addresses further after all globals have been
-            // parsed to span the gaps, or we can find the global variable
-            // sizes from the DWARF info as we are parsing.
-
-            // Next we find the non-stab entry that corresponds to the N_GSYM in
-            // the .o file
+            // For each N_GSYM we remap the address for the global by
+            // making a new section that we add to the sections found in
+            // the .o file. This new section has the file address set to
+            // what the addresses are in the .o file, and the load address
+            // is adjusted to match where it ended up in the final
+            // executable! We do this before we parse any dwarf info so
+            // that when it goes get parsed all section/offset addresses
+            // that get registered will resolve correctly to the new
+            // addresses in the main executable. We initially set the
+            // section size to be 1 byte, but will need to fix up these
+            // addresses further after all globals have been parsed to
+            // span the gaps, or we can find the global variable sizes
+            // from the DWARF info as we are parsing.
+
+            // Next we find the non-stab entry that corresponds to the
+            // N_GSYM in the .o file
             Symbol *oso_gsym_symbol =
                 oso_symtab->FindFirstSymbolWithNameAndType(
                     exe_symbol->GetMangled().GetName(lldb::eLanguageTypeUnknown,
@@ -151,7 +154,8 @@
                     eSymbolTypeData, Symtab::eDebugNo, Symtab::eVisibilityAny);
             if (exe_symbol && oso_gsym_symbol && exe_symbol->ValueIsAddress() &&
                 oso_gsym_symbol->ValueIsAddress()) {
-              // Add the inverse OSO file address to debug map entry mapping
+              // Add the inverse OSO file address to debug map entry
+              // mapping
               exe_symfile->AddOSOFileRange(
                   this, exe_symbol->GetAddressRef().GetFileAddress(),
                   exe_symbol->GetByteSize(),
@@ -267,13 +271,15 @@
 
   m_flags.set(kHaveInitializedOSOs);
 
-  // If the object file has been stripped, there is no sense in looking further
-  // as all of the debug symbols for the debug map will not be available
+  // If the object file has been stripped, there is no sense in looking
+  // further as all of the debug symbols for the debug map will not be
+  // available
   if (m_obj_file->IsStripped())
     return;
 
-  // Also make sure the file type is some sort of executable. Core files, debug
-  // info files (dSYM), object files (.o files), and stub libraries all can
+  // Also make sure the file type is some sort of executable. Core files,
+  // debug info files (dSYM), object files (.o files), and stub libraries
+  // all can
   switch (m_obj_file->GetType()) {
   case ObjectFile::eTypeInvalid:
   case ObjectFile::eTypeCoreFile:
@@ -300,13 +306,13 @@
     Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_MAP));
 
     std::vector<uint32_t> oso_indexes;
-    // When a mach-o symbol is encoded, the n_type field is encoded in bits
-    // 23:16, and the n_desc field is encoded in bits 15:0.
+    // When a mach-o symbol is encoded, the n_type field is encoded in
+    // bits 23:16, and the n_desc field is encoded in bits 15:0.
     //
-    // To find all N_OSO entries that are part of the DWARF + debug map
-    // we find only object file symbols with the flags value as follows:
-    // bits 23:16 == 0x66 (N_OSO)
-    // bits 15: 0 == 0x0001 (specifies this is a debug map object file)
+    // To find all N_OSO entries that are part of the DWARF + debug map we
+    // find only object file symbols with the flags value as follows: bits
+    // 23:16 == 0x66 (N_OSO) bits 15: 0 == 0x0001 (specifies this is a
+    // debug map object file)
     const uint32_t k_oso_symbol_flags_value = 0x660001u;
 
     const uint32_t oso_index_count =
@@ -358,8 +364,8 @@
           m_compile_unit_infos[i].oso_mod_time =
               llvm::sys::toTimePoint(oso_symbol->GetIntegerValue(0));
           uint32_t sibling_idx = so_symbol->GetSiblingIndex();
-          // The sibling index can't be less that or equal to the current index
-          // "i"
+          // The sibling index can't be less that or equal to the current
+          // index "i"
           if (sibling_idx == UINT32_MAX) {
             m_obj_file->GetModule()->ReportError(
                 "N_SO in symbol with UID %u has invalid sibling in debug map, "
@@ -443,16 +449,15 @@
           return NULL;
         }
       }
-      // Always create a new module for .o files. Why? Because we
-      // use the debug map, to add new sections to each .o file and
-      // even though a .o file might not have changed, the sections
-      // that get added to the .o file can change.
+      // Always create a new module for .o files. Why? Because we use the
+      // debug map, to add new sections to each .o file and even though a
+      // .o file might not have changed, the sections that get added to
+      // the .o file can change.
       ArchSpec oso_arch;
-      // Only adopt the architecture from the module (not the vendor or OS)
-      // since .o files for "i386-apple-ios" will historically show up as
-      // "i386-apple-macosx"
-      // due to the lack of a LC_VERSION_MIN_MACOSX or LC_VERSION_MIN_IPHONEOS
-      // load command...
+      // Only adopt the architecture from the module (not the vendor or
+      // OS) since .o files for "i386-apple-ios" will historically show up
+      // as "i386-apple-macosx" due to the lack of a LC_VERSION_MIN_MACOSX
+      // or LC_VERSION_MIN_IPHONEOS load command...
       oso_arch.SetTriple(m_obj_file->GetModule()
                              ->GetArchitecture()
                              .GetTriple()
@@ -576,9 +581,9 @@
     if (oso_module) {
       FileSpec so_file_spec;
       if (GetFileSpecForSO(cu_idx, so_file_spec)) {
-        // User zero as the ID to match the compile unit at offset
-        // zero in each .o file since each .o file can only have
-        // one compile unit for now.
+        // User zero as the ID to match the compile unit at offset zero in
+        // each .o file since each .o file can only have one compile unit
+        // for now.
         lldb::user_id_t cu_id = 0;
         m_compile_unit_infos[cu_idx].compile_unit_sp.reset(
             new CompileUnit(m_obj_file->GetModule(), NULL, so_file_spec, cu_id,
@@ -774,8 +779,8 @@
     if (!resolve) {
       FileSpec so_file_spec;
       if (GetFileSpecForSO(i, so_file_spec)) {
-        // Match the full path if the incoming file_spec has a directory (not
-        // just a basename)
+        // Match the full path if the incoming file_spec has a directory
+        // (not just a basename)
         const bool full_match = (bool)file_spec.GetDirectory();
         resolve = FileSpec::Equal(file_spec, so_file_spec, full_match);
       }
@@ -966,11 +971,11 @@
                                                 SymbolContextList &sc_list,
                                                 uint32_t start_idx) {
   // We found functions in .o files. Not all functions in the .o files
-  // will have made it into the final output file. The ones that did
-  // make it into the final output file will have a section whose module
-  // matches the module from the ObjectFile for this SymbolFile. When
-  // the modules don't match, then we have something that was in a
-  // .o file, but doesn't map to anything in the final executable.
+  // will have made it into the final output file. The ones that did make
+  // it into the final output file will have a section whose module
+  // matches the module from the ObjectFile for this SymbolFile. When the
+  // modules don't match, then we have something that was in a .o file,
+  // but doesn't map to anything in the final executable.
   uint32_t i = start_idx;
   while (i < sc_list.GetSize()) {
     SymbolContext sc;
@@ -1101,12 +1106,12 @@
 TypeSP SymbolFileDWARFDebugMap::FindCompleteObjCDefinitionTypeForDIE(
     const DWARFDIE &die, const ConstString &type_name,
     bool must_be_implementation) {
-  // If we have a debug map, we will have an Objective C symbol whose name is
-  // the type name and whose type is eSymbolTypeObjCClass. If we can find that
-  // symbol and find its containing parent, we can locate the .o file that will
-  // contain the implementation definition since it will be scoped inside the
-  // N_SO
-  // and we can then locate the SymbolFileDWARF that corresponds to that N_SO.
+  // If we have a debug map, we will have an Objective C symbol whose name
+  // is the type name and whose type is eSymbolTypeObjCClass. If we can
+  // find that symbol and find its containing parent, we can locate the .o
+  // file that will contain the implementation definition since it will be
+  // scoped inside the N_SO and we can then locate the SymbolFileDWARF
+  // that corresponds to that N_SO.
   SymbolFileDWARF *oso_dwarf = NULL;
   TypeSP type_sp;
   ObjectFile *module_objfile = m_obj_file->GetModule()->GetObjectFile();
@@ -1117,9 +1122,9 @@
           type_name, eSymbolTypeObjCClass, Symtab::eDebugAny,
           Symtab::eVisibilityAny);
       if (objc_class_symbol) {
-        // Get the N_SO symbol that contains the objective C class symbol as
-        // this
-        // should be the .o file that contains the real definition...
+        // Get the N_SO symbol that contains the objective C class symbol
+        // as this should be the .o file that contains the real
+        // definition...
         const Symbol *source_file_symbol = symtab->GetParent(objc_class_symbol);
 
         if (source_file_symbol &&
@@ -1147,10 +1152,8 @@
   }
 
   // Only search all .o files for the definition if we don't need the
-  // implementation
-  // because otherwise, with a valid debug map we should have the ObjC class
-  // symbol and
-  // the code above should have found it.
+  // implementation because otherwise, with a valid debug map we should
+  // have the ObjC class symbol and the code above should have found it.
   if (must_be_implementation == false) {
     TypeSP type_sp;
 
@@ -1199,8 +1202,8 @@
 //
 // uint32_t
 // SymbolFileDWARFDebugMap::FindTypes (const SymbolContext& sc, const
-// RegularExpression& regex, bool append, uint32_t max_matches, Type::Encoding
-// encoding, lldb::user_id_t udt_uid, TypeList& types)
+// RegularExpression& regex, bool append, uint32_t max_matches,
+// Type::Encoding encoding, lldb::user_id_t udt_uid, TypeList& types)
 //{
 //  SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
 //  if (oso_dwarf)
Index: source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp
+++ source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp
@@ -62,7 +62,8 @@
 
 DWARFUnit *SymbolFileDWARFDwo::GetCompileUnit() {
   // A clang module is found via a skeleton CU, but is not a proper DWO.
-  // Clang modules have a .debug_info section instead of the *_dwo variant.
+  // Clang modules have a .debug_info section instead of the *_dwo
+  // variant.
   if (auto *section_list = m_obj_file->GetSectionList(false))
     if (auto section_sp =
             section_list->FindSectionByType(eSectionTypeDWARFDebugInfo, true))
Index: source/Plugins/SymbolFile/DWARF/UniqueDWARFASTType.cpp
===================================================================
--- source/Plugins/SymbolFile/DWARF/UniqueDWARFASTType.cpp
+++ source/Plugins/SymbolFile/DWARF/UniqueDWARFASTType.cpp
@@ -27,8 +27,8 @@
           udt.m_byte_size == byte_size) {
         // Make sure the file and line match
         if (udt.m_declaration == decl) {
-          // The type has the same name, and was defined on the same
-          // file and line. Now verify all of the parent DIEs match.
+          // The type has the same name, and was defined on the same file
+          // and line. Now verify all of the parent DIEs match.
           DWARFDIE parent_arg_die = die.GetParent();
           DWARFDIE parent_pos_die = udt.m_die.GetParent();
           bool match = true;
Index: source/Plugins/SymbolFile/PDB/PDBASTParser.cpp
===================================================================
--- source/Plugins/SymbolFile/PDB/PDBASTParser.cpp
+++ source/Plugins/SymbolFile/PDB/PDBASTParser.cpp
@@ -131,10 +131,10 @@
   case PDB_BuiltinType::Char32:
     return CompilerType(ast, ast->Char32Ty);
   case PDB_BuiltinType::Float:
-    // Note: types `long double` and `double` have same bit size in MSVC and
-    // there is no information in the PDB to distinguish them. So when falling
-    // back to default search, the compiler type of `long double` will be
-    // represented by the one generated for `double`.
+    // Note: types `long double` and `double` have same bit size in MSVC
+    // and there is no information in the PDB to distinguish them. So when
+    // falling back to default search, the compiler type of `long double`
+    // will be represented by the one generated for `double`.
     break;
   }
   // If there is no match on PDB_BuiltinType, fall back to default search
@@ -207,10 +207,10 @@
 // DebugInfoASTParser interface
 
 lldb::TypeSP PDBASTParser::CreateLLDBTypeFromPDBType(const PDBSymbol &type) {
-  // PDB doesn't maintain enough information to robustly rebuild the entire
-  // tree, and this is most problematic when it comes to figure out the
-  // right DeclContext to put a type in.  So for now, everything goes in
-  // the translation unit decl as a fully qualified type.
+  // PDB doesn't maintain enough information to robustly rebuild the
+  // entire tree, and this is most problematic when it comes to figure out
+  // the right DeclContext to put a type in.  So for now, everything goes
+  // in the translation unit decl as a fully qualified type.
   clang::DeclContext *tu_decl_ctx = m_ast.GetTranslationUnitDecl();
   Declaration decl;
 
@@ -247,8 +247,8 @@
       return nullptr;
     lldb::Encoding encoding =
         TranslateBuiltinEncoding(underlying_type_up->getBuiltinType());
-    // FIXME: Type of underlying builtin is always `Int`. We correct it with
-    // the very first enumerator's encoding if any.
+    // FIXME: Type of underlying builtin is always `Int`. We correct it
+    // with the very first enumerator's encoding if any.
     auto first_child = enum_type->findOneChild<PDBSymbolData>();
     if (first_child) {
       encoding = TranslateEnumEncoding(first_child->getValue().Type);
@@ -341,8 +341,8 @@
         break;
       lldb_private::Type *arg_type =
           m_ast.GetSymbolFile()->ResolveTypeUID(arg->getSymIndexId());
-      // If there's some error looking up one of the dependent types of this
-      // function signature, bail.
+      // If there's some error looking up one of the dependent types of
+      // this function signature, bail.
       if (!arg_type)
         return nullptr;
       CompilerType arg_ast_type = arg_type->GetFullCompilerType();
@@ -380,8 +380,8 @@
     uint32_t element_uid = array_type->getElementTypeId();
     uint32_t bytes = array_type->getLength();
 
-    // If array rank > 0, PDB gives the element type at N=0. So element type
-    // will parsed in the order N=0, N=1,..., N=rank sequentially.
+    // If array rank > 0, PDB gives the element type at N=0. So element
+    // type will parsed in the order N=0, N=1,..., N=rank sequentially.
     lldb_private::Type *element_type =
         m_ast.GetSymbolFile()->ResolveTypeUID(element_uid);
     if (!element_type)
Index: source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp
===================================================================
--- source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp
+++ source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp
@@ -184,16 +184,17 @@
     // The linker could link *.dll (compiland language = LINK), or import
     // *.dll. For example, a compiland with name `Import:KERNEL32.dll`
     // could be found as a child of the global scope (PDB executable).
-    // Usually, such compilands contain `thunk` symbols in which we are not
-    // interested for now. However we still count them in the compiland list.
-    // If we perform any compiland related activity, like finding symbols
-    // through llvm::pdb::IPDBSession methods, such compilands will all be
-    // searched automatically no matter whether we include them or not.
+    // Usually, such compilands contain `thunk` symbols in which we are
+    // not interested for now. However we still count them in the
+    // compiland list. If we perform any compiland related activity, like
+    // finding symbols through llvm::pdb::IPDBSession methods, such
+    // compilands will all be searched automatically no matter whether we
+    // include them or not.
     m_cached_compile_unit_count = compilands->getChildCount();
 
-    // The linker can inject an additional "dummy" compilation unit into the
-    // PDB. Ignore this special compile unit for our purposes, if it is there.
-    // It is always the last one.
+    // The linker can inject an additional "dummy" compilation unit into
+    // the PDB. Ignore this special compile unit for our purposes, if it
+    // is there. It is always the last one.
     auto last_compiland_up =
         compilands->getChildAtIndex(m_cached_compile_unit_count - 1);
     lldbassert(last_compiland_up.get());
@@ -232,9 +233,9 @@
   if (index >= GetNumCompileUnits())
     return CompUnitSP();
 
-  // Assuming we always retrieve same compilands listed in same order through
-  // `PDBSymbolExe::findAllChildren` method, otherwise using `index` to get a
-  // compile unit makes no sense.
+  // Assuming we always retrieve same compilands listed in same order
+  // through `PDBSymbolExe::findAllChildren` method, otherwise using
+  // `index` to get a compile unit makes no sense.
   auto results = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
   if (!results)
     return CompUnitSP();
@@ -246,8 +247,8 @@
 
 lldb::LanguageType
 SymbolFilePDB::ParseCompileUnitLanguage(const lldb_private::SymbolContext &sc) {
-  // What fields should I expect to be filled out on the SymbolContext?  Is it
-  // safe to assume that `sc.comp_unit` is valid?
+  // What fields should I expect to be filled out on the SymbolContext?
+  // Is it safe to assume that `sc.comp_unit` is valid?
   if (!sc.comp_unit)
     return lldb::eLanguageTypeUnknown;
 
@@ -330,11 +331,11 @@
     lldb_private::FileSpecList &support_files) {
   lldbassert(sc.comp_unit);
 
-  // In theory this is unnecessary work for us, because all of this information
-  // is easily (and quickly) accessible from DebugInfoPDB, so caching it a
-  // second time seems like a waste.  Unfortunately, there's no good way around
-  // this short of a moderate refactor since SymbolVendor depends on being able
-  // to cache this list.
+  // In theory this is unnecessary work for us, because all of this
+  // information is easily (and quickly) accessible from DebugInfoPDB, so
+  // caching it a second time seems like a waste.  Unfortunately, there's
+  // no good way around this short of a moderate refactor since
+  // SymbolVendor depends on being able to cache this list.
   auto compiland_up = GetPDBCompilandByUID(sc.comp_unit->GetID());
   if (!compiland_up)
     return false;
@@ -450,8 +451,8 @@
           continue;
         }
 
-        // This should cause the type to get cached and stored in the `m_types`
-        // lookup.
+        // This should cause the type to get cached and stored in the
+        // `m_types` lookup.
         if (!ResolveTypeUID(symbol->getSymIndexId()))
           continue;
 
@@ -470,8 +471,8 @@
     ParseTypesByTagFn(*compiland);
 
     // Also parse global types particularly coming from this compiland.
-    // Unfortunately, PDB has no compiland information for each global type.
-    // We have to parse them all. But ensure we only do this once.
+    // Unfortunately, PDB has no compiland information for each global
+    // type. We have to parse them all. But ensure we only do this once.
     static bool parse_all_global_types = false;
     if (!parse_all_global_types) {
       ParseTypesByTagFn(*m_global_scope_up);
@@ -528,9 +529,9 @@
 
 lldb_private::CompilerDeclContext
 SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) {
-  // PDB always uses the translation unit decl context for everything.  We can
-  // improve this later but it's not easy because PDB doesn't provide a high
-  // enough level of type fidelity in this area.
+  // PDB always uses the translation unit decl context for everything.  We
+  // can improve this later but it's not easy because PDB doesn't provide
+  // a high enough level of type fidelity in this area.
   return *m_tu_decl_ctx_up;
 }
 
@@ -609,23 +610,23 @@
     uint32_t resolve_scope, lldb_private::SymbolContextList &sc_list) {
   const size_t old_size = sc_list.GetSize();
   if (resolve_scope & lldb::eSymbolContextCompUnit) {
-    // Locate all compilation units with line numbers referencing the specified
-    // file.  For example, if `file_spec` is <vector>, then this should return
-    // all source files and header files that reference <vector>, either
-    // directly or indirectly.
+    // Locate all compilation units with line numbers referencing the
+    // specified file.  For example, if `file_spec` is <vector>, then this
+    // should return all source files and header files that reference
+    // <vector>, either directly or indirectly.
     auto compilands = m_session_up->findCompilandsForSourceFile(
         file_spec.GetPath(), PDB_NameSearchFlags::NS_CaseInsensitive);
 
     if (!compilands)
       return 0;
 
-    // For each one, either find its previously parsed data or parse it afresh
-    // and add it to the symbol context list.
+    // For each one, either find its previously parsed data or parse it
+    // afresh and add it to the symbol context list.
     while (auto compiland = compilands->getNext()) {
-      // If we're not checking inlines, then don't add line information for this
-      // file unless the FileSpec matches.
-      // For inline functions, we don't have to match the FileSpec since they
-      // could be defined in headers other than file specified in FileSpec.
+      // If we're not checking inlines, then don't add line information
+      // for this file unless the FileSpec matches. For inline functions,
+      // we don't have to match the FileSpec since they could be defined
+      // in headers other than file specified in FileSpec.
       if (!check_inlines) {
         std::string source_file = compiland->getSourceFileFullPath();
         if (source_file.empty())
@@ -643,18 +644,21 @@
       sc.comp_unit = cu.get();
       sc.module_sp = cu->GetModule();
 
-      // If we were asked to resolve line entries, add all entries to the line
-      // table that match the requested line (or all lines if `line` == 0).
+      // If we were asked to resolve line entries, add all entries to the
+      // line table that match the requested line (or all lines if `line`
+      // == 0).
       if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock |
                            eSymbolContextLineEntry)) {
         bool has_line_table = ParseCompileUnitLineTable(sc, line);
 
         if ((resolve_scope & eSymbolContextLineEntry) && !has_line_table) {
-          // The query asks for line entries, but we can't get them for the
-          // compile unit. This is not normal for `line` = 0. So just assert it.
+          // The query asks for line entries, but we can't get them for
+          // the compile unit. This is not normal for `line` = 0. So just
+          // assert it.
           assert(line && "Couldn't get all line entries!\n");
 
-          // Current compiland does not have the requested line. Search next.
+          // Current compiland does not have the requested line. Search
+          // next.
           continue;
         }
 
@@ -773,16 +777,17 @@
 
       if (auto parent = pdb_func_up->getClassParent()) {
 
-        // PDB have symbols for class/struct methods or static methods in Enum
-        // Class. We won't bother to check if the parent is UDT or Enum here.
+        // PDB have symbols for class/struct methods or static methods in
+        // Enum Class. We won't bother to check if the parent is UDT or
+        // Enum here.
         m_func_method_names.Append(ConstString(name), uid);
 
         ConstString cstr_name(name);
 
-        // To search a method name, like NS::Class:MemberFunc, LLDB searches its
-        // base name, i.e. MemberFunc by default. Since PDBSymbolFunc does not
-        // have inforamtion of this, we extract base names and cache them by our
-        // own effort.
+        // To search a method name, like NS::Class:MemberFunc, LLDB
+        // searches its base name, i.e. MemberFunc by default. Since
+        // PDBSymbolFunc does not have inforamtion of this, we extract
+        // base names and cache them by our own effort.
         llvm::StringRef basename;
         CPlusPlusLanguage::MethodName cpp_method(cstr_name);
         if (cpp_method.IsValid()) {
@@ -805,10 +810,10 @@
       } else {
         // Handle not-method symbols.
 
-        // The function name might contain namespace, or its lexical scope. It
-        // is not safe to get its base name by applying same scheme as we deal
-        // with the method names.
-        // FIXME: Remove namespace if function is static in a scope.
+        // The function name might contain namespace, or its lexical
+        // scope. It is not safe to get its base name by applying same
+        // scheme as we deal with the method names. FIXME: Remove
+        // namespace if function is static in a scope.
         m_func_base_names.Append(ConstString(name), uid);
 
         if (name == "main") {
@@ -966,12 +971,13 @@
 void SymbolFilePDB::FindTypesByRegex(
     const lldb_private::RegularExpression &regex, uint32_t max_matches,
     lldb_private::TypeMap &types) {
-  // When searching by regex, we need to go out of our way to limit the search
-  // space as much as possible since this searches EVERYTHING in the PDB,
-  // manually doing regex comparisons.  PDB library isn't optimized for regex
-  // searches or searches across multiple symbol types at the same time, so the
-  // best we can do is to search enums, then typedefs, then classes one by one,
-  // and do a regex comparison against each of them.
+  // When searching by regex, we need to go out of our way to limit the
+  // search space as much as possible since this searches EVERYTHING in
+  // the PDB, manually doing regex comparisons.  PDB library isn't
+  // optimized for regex searches or searches across multiple symbol types
+  // at the same time, so the best we can do is to search enums, then
+  // typedefs, then classes one by one, and do a regex comparison against
+  // each of them.
   PDB_SymType tags_to_search[] = {PDB_SymType::Enum, PDB_SymType::Typedef,
                                   PDB_SymType::UDT};
   std::unique_ptr<IPDBEnumSymbols> results;
@@ -996,16 +1002,16 @@
       else if (auto class_type = llvm::dyn_cast<PDBSymbolTypeUDT>(result.get()))
         type_name = class_type->getName();
       else {
-        // We're looking only for types that have names.  Skip symbols, as well
-        // as unnamed types such as arrays, pointers, etc.
+        // We're looking only for types that have names.  Skip symbols, as
+        // well as unnamed types such as arrays, pointers, etc.
         continue;
       }
 
       if (!regex.Execute(type_name))
         continue;
 
-      // This should cause the type to get cached and stored in the `m_types`
-      // lookup.
+      // This should cause the type to get cached and stored in the
+      // `m_types` lookup.
       if (!ResolveTypeUID(result->getSymIndexId()))
         continue;
 
@@ -1040,13 +1046,13 @@
     case PDB_SymType::Typedef:
       break;
     default:
-      // We're looking only for types that have names.  Skip symbols, as well as
-      // unnamed types such as arrays, pointers, etc.
+      // We're looking only for types that have names.  Skip symbols, as
+      // well as unnamed types such as arrays, pointers, etc.
       continue;
     }
 
-    // This should cause the type to get cached and stored in the `m_types`
-    // lookup.
+    // This should cause the type to get cached and stored in the
+    // `m_types` lookup.
     if (!ResolveTypeUID(result->getSymIndexId()))
       continue;
 
@@ -1200,8 +1206,8 @@
   if (path.empty())
     return CompUnitSP();
 
-  // Don't support optimized code for now, DebugInfoPDB does not return this
-  // information.
+  // Don't support optimized code for now, DebugInfoPDB does not return
+  // this information.
   LazyBool optimized = eLazyBoolNo;
   auto cu_sp = std::make_shared<CompileUnit>(m_obj_file->GetModule(), nullptr,
                                              path.c_str(), id, lang, optimized);
@@ -1226,10 +1232,10 @@
   if (!compiland_up)
     return false;
 
-  // LineEntry needs the *index* of the file into the list of support files
-  // returned by ParseCompileUnitSupportFiles.  But the underlying SDK gives us
-  // a globally unique idenfitifier in the namespace of the PDB.  So, we have to
-  // do a mapping so that we can hand out indices.
+  // LineEntry needs the *index* of the file into the list of support
+  // files returned by ParseCompileUnitSupportFiles.  But the underlying
+  // SDK gives us a globally unique idenfitifier in the namespace of the
+  // PDB.  So, we have to do a mapping so that we can hand out indices.
   llvm::DenseMap<uint32_t, uint32_t> index_map;
   BuildSupportFileIdToSupportFileIndexMap(*compiland_up, index_map);
   auto line_table = llvm::make_unique<LineTable>(sc.comp_unit);
@@ -1240,8 +1246,8 @@
   if (!files)
     return false;
 
-  // For each source and header file, create a LineSequence for contributions to
-  // the compiland from that file, and add the sequence.
+  // For each source and header file, create a LineSequence for
+  // contributions to the compiland from that file, and add the sequence.
   while (auto file = files->getNext()) {
     std::unique_ptr<LineSequence> sequence(
         line_table->CreateLineSequenceContainer());
@@ -1265,13 +1271,13 @@
       uint32_t col = line->getColumnNumber();
       uint32_t source_idx = index_map[source_id];
 
-      // There was a gap between the current entry and the previous entry if the
-      // addresses don't perfectly line up.
+      // There was a gap between the current entry and the previous entry
+      // if the addresses don't perfectly line up.
       bool is_gap = (i > 0) && (prev_addr + prev_length < addr);
 
-      // Before inserting the current entry, insert a terminal entry at the end
-      // of the previous entry's address range if the current entry resulted in
-      // a gap from the previous entry.
+      // Before inserting the current entry, insert a terminal entry at
+      // the end of the previous entry's address range if the current
+      // entry resulted in a gap from the previous entry.
       if (is_gap && ShouldAddLine(match_line, prev_line, prev_length)) {
         line_table->AppendLineEntryToSequence(
             sequence.get(), prev_addr + prev_length, prev_line, 0,
@@ -1325,11 +1331,12 @@
 void SymbolFilePDB::BuildSupportFileIdToSupportFileIndexMap(
     const PDBSymbolCompiland &compiland,
     llvm::DenseMap<uint32_t, uint32_t> &index_map) const {
-  // This is a hack, but we need to convert the source id into an index into the
-  // support files array.  We don't want to do path comparisons to avoid
-  // basename / full path issues that may or may not even be a problem, so we
-  // use the globally unique source file identifiers.  Ideally we could use the
-  // global identifiers everywhere, but LineEntry currently assumes indices.
+  // This is a hack, but we need to convert the source id into an index
+  // into the support files array.  We don't want to do path comparisons
+  // to avoid basename / full path issues that may or may not even be a
+  // problem, so we use the globally unique source file identifiers.
+  // Ideally we could use the global identifiers everywhere, but LineEntry
+  // currently assumes indices.
   auto source_files = m_session_up->getSourceFilesForCompiland(compiland);
   if (!source_files)
     return;
@@ -1372,9 +1379,9 @@
   auto func_undecorated_name = pdb_func.getUndecoratedName();
   std::string func_decorated_name;
 
-  // Seek from public symbols for non-static function's decorated name if any.
-  // For static functions, they don't have undecorated names and aren't exposed
-  // in Public Symbols either.
+  // Seek from public symbols for non-static function's decorated name if
+  // any. For static functions, they don't have undecorated names and
+  // aren't exposed in Public Symbols either.
   if (!func_undecorated_name.empty()) {
     auto result_up = m_global_scope_up->findChildren(
         PDB_SymType::PublicSymbol, func_undecorated_name,
@@ -1398,9 +1405,9 @@
     mangled.SetMangledName(ConstString(func_decorated_name));
 
     // For MSVC, format of C funciton's decorated name depends on calling
-    // conventon. Unfortunately none of the format is recognized by current
-    // LLDB. For example, `_purecall` is a __cdecl C function. From PDB,
-    // `__purecall` is retrieved as both its decorated and
+    // conventon. Unfortunately none of the format is recognized by
+    // current LLDB. For example, `_purecall` is a __cdecl C function.
+    // From PDB, `__purecall` is retrieved as both its decorated and
     // undecorated name (using PDBSymbolFunc::getUndecoratedName method).
     // However `__purecall` string is not treated as mangled in LLDB
     // (neither `?` nor `_Z` prefix). Mangled::GetDemangledName method
@@ -1413,10 +1420,10 @@
       mangled.SetDemangledName(ConstString(func_undecorated_name));
 
     // LLDB uses several flags to control how a C++ decorated name is
-    // undecorated for MSVC. See `safeUndecorateName` in Class Mangled.
-    // So the yielded name could be different from what we retrieve from
-    // PDB source unless we also apply same flags in getting undecorated
-    // name through PDBSymbolFunc::getUndecoratedNameEx method.
+    // undecorated for MSVC. See `safeUndecorateName` in Class Mangled. So
+    // the yielded name could be different from what we retrieve from PDB
+    // source unless we also apply same flags in getting undecorated name
+    // through PDBSymbolFunc::getUndecoratedNameEx method.
     if (!func_undecorated_name.empty() &&
         mangled.GetDemangledName(mangled.GuessLanguage()) !=
             ConstString(func_undecorated_name))
Index: source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp
===================================================================
--- source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp
+++ source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp
@@ -64,8 +64,8 @@
     if (symtab) {
       //----------------------------------------------------------------------
       // The snippet of code below will get the indexes the module symbol
-      // table entries that are code, data, or function related (debug info),
-      // sort them by value (address) and dump the sorted symbols.
+      // table entries that are code, data, or function related (debug
+      // info), sort them by value (address) and dump the sorted symbols.
       //----------------------------------------------------------------------
       if (symtab->AppendSymbolIndexesWithType(eSymbolTypeSourceFile,
                                               m_source_indexes)) {
@@ -105,24 +105,21 @@
 }
 
 uint32_t SymbolFileSymtab::GetNumCompileUnits() {
-  // If we don't have any source file symbols we will just have one compile unit
-  // for
-  // the entire object file
+  // If we don't have any source file symbols we will just have one
+  // compile unit for the entire object file
   if (m_source_indexes.empty())
     return 0;
 
-  // If we have any source file symbols we will logically organize the object
-  // symbols
-  // using these.
+  // If we have any source file symbols we will logically organize the
+  // object symbols using these.
   return m_source_indexes.size();
 }
 
 CompUnitSP SymbolFileSymtab::ParseCompileUnitAtIndex(uint32_t idx) {
   CompUnitSP cu_sp;
 
-  // If we don't have any source file symbols we will just have one compile unit
-  // for
-  // the entire object file
+  // If we don't have any source file symbols we will just have one
+  // compile unit for the entire object file
   if (idx < m_source_indexes.size()) {
     const Symbol *cu_symbol =
         m_obj_file->GetSymtab()->SymbolAtIndex(m_source_indexes[idx]);
@@ -152,9 +149,8 @@
   //
   //  const uint32_t prefix_len = strlen(prefix);
 
-  // If we don't have any source file symbols we will just have one compile unit
-  // for
-  // the entire object file
+  // If we don't have any source file symbols we will just have one
+  // compile unit for the entire object file
   if (m_source_indexes.empty()) {
     // The only time we will have a user ID of zero is when we don't have
     // and source file symbols and we declare one compile unit for the
Index: source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp
===================================================================
--- source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp
+++ source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp
@@ -57,9 +57,9 @@
 //----------------------------------------------------------------------
 // CreateInstance
 //
-// Platforms can register a callback to use when creating symbol
-// vendors to allow for complex debug information file setups, and to
-// also allow for finding separate debug information files.
+// Platforms can register a callback to use when creating symbol vendors
+// to allow for complex debug information file setups, and to also allow
+// for finding separate debug information files.
 //----------------------------------------------------------------------
 SymbolVendor *
 SymbolVendorELF::CreateInstance(const lldb::ModuleSP &module_sp,
@@ -112,17 +112,15 @@
           module_sp, &dsym_fspec, 0, dsym_fspec.GetByteSize(),
           dsym_file_data_sp, dsym_file_data_offset);
       if (dsym_objfile_sp) {
-        // This objfile is for debugging purposes. Sadly, ObjectFileELF won't be
-        // able
-        // to figure this out consistently as the symbol file may not have
-        // stripped the
-        // code sections, etc.
+        // This objfile is for debugging purposes. Sadly, ObjectFileELF
+        // won't be able to figure this out consistently as the symbol
+        // file may not have stripped the code sections, etc.
         dsym_objfile_sp->SetType(ObjectFile::eTypeDebugInfo);
 
         SymbolVendorELF *symbol_vendor = new SymbolVendorELF(module_sp);
         if (symbol_vendor) {
-          // Get the module unified section list and add our debug sections to
-          // that.
+          // Get the module unified section list and add our debug
+          // sections to that.
           SectionList *module_section_list = module_sp->GetSectionList();
           SectionList *objfile_section_list = dsym_objfile_sp->GetSectionList();
 
Index: source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp
===================================================================
--- source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp
+++ source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp
@@ -94,9 +94,9 @@
 //----------------------------------------------------------------------
 // CreateInstance
 //
-// Platforms can register a callback to use when creating symbol
-// vendors to allow for complex debug information file setups, and to
-// also allow for finding separate debug information files.
+// Platforms can register a callback to use when creating symbol vendors
+// to allow for complex debug information file setups, and to also allow
+// for finding separate debug information files.
 //----------------------------------------------------------------------
 SymbolVendor *
 SymbolVendorMacOSX::CreateInstance(const lldb::ModuleSP &module_sp,
@@ -136,8 +136,8 @@
 
     ObjectFileSP dsym_objfile_sp;
     if (!dsym_fspec) {
-      // No symbol file was specified in the module, lets try and find
-      // one ourselves.
+      // No symbol file was specified in the module, lets try and find one
+      // ourselves.
       FileSpec file_spec = obj_file->GetFileSpec();
       if (!file_spec)
         file_spec = module_sp->GetFileSpec();
@@ -179,10 +179,10 @@
                       std::string DBGBuildSourcePath;
                       std::string DBGSourcePath;
 
-                      // DBGSourcePathRemapping is a dictionary in the plist
-                      // with
-                      // keys which are DBGBuildSourcePath file paths and
-                      // values which are DBGSourcePath file paths
+                      // DBGSourcePathRemapping is a dictionary in the
+                      // plist with keys which are DBGBuildSourcePath file
+                      // paths and values which are DBGSourcePath file
+                      // paths
 
                       StructuredData::ObjectSP plist_sp =
                           plist.GetStructuredData();
@@ -193,17 +193,16 @@
                               ->GetValueForKey("DBGSourcePathRemapping")
                               ->GetAsDictionary()) {
 
-                        // In an early version of DBGSourcePathRemapping, the
-                        // DBGSourcePath
-                        // values were incorrect.  If we have a newer style
-                        // DBGSourcePathRemapping, there will be a DBGVersion
-                        // key in the plist with version 2 or higher.
+                        // In an early version of DBGSourcePathRemapping,
+                        // the DBGSourcePath values were incorrect.  If we
+                        // have a newer style DBGSourcePathRemapping,
+                        // there will be a DBGVersion key in the plist
+                        // with version 2 or higher.
                         //
                         // If this is an old style DBGSourcePathRemapping,
-                        // ignore the
-                        // value half of the key-value remappings and use reuse
-                        // the original
-                        // gloal DBGSourcePath string.
+                        // ignore the value half of the key-value
+                        // remappings and use reuse the original gloal
+                        // DBGSourcePath string.
                         bool new_style_source_remapping_dictionary = false;
                         bool do_truncate_remapping_names = false;
                         std::string original_DBGSourcePath_value =
@@ -253,10 +252,13 @@
                                 }
                                 module_sp->GetSourceMappingList().Append(
                                     key, ConstString(DBGSourcePath), true);
-                                // With version 2 of DBGSourcePathRemapping, we can chop off the
-                                // last two filename parts from the source remapping and get a
-                                // more general source remapping that still works.  Add this as
-                                // another option in addition to the full source path remap.
+                                // With version 2 of
+                                // DBGSourcePathRemapping, we can chop off
+                                // the last two filename parts from the
+                                // source remapping and get a more general
+                                // source remapping that still works.  Add
+                                // this as another option in addition to
+                                // the full source path remap.
                                 if (do_truncate_remapping_names) {
                                   FileSpec build_path(key.AsCString(), false);
                                   FileSpec source_path(DBGSourcePath.c_str(), false);
@@ -273,8 +275,8 @@
                             });
                       }
 
-                      // If we have a DBGBuildSourcePath + DBGSourcePath pair,
-                      // append those to the source path remappings.
+                      // If we have a DBGBuildSourcePath + DBGSourcePath
+                      // pair, append those to the source path remappings.
 
                       plist.GetValueAsString("DBGBuildSourcePath",
                                              DBGBuildSourcePath);
@@ -303,9 +305,9 @@
       }
     }
 
-    // Just create our symbol vendor using the current objfile as this is either
-    // an executable with no dSYM (that we could locate), an executable with
-    // a dSYM that has a UUID that doesn't match.
+    // Just create our symbol vendor using the current objfile as this is
+    // either an executable with no dSYM (that we could locate), an
+    // executable with a dSYM that has a UUID that doesn't match.
     symbol_vendor->AddSymbolFileRepresentation(obj_file->shared_from_this());
   }
   return symbol_vendor;
Index: source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp
===================================================================
--- source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp
+++ source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp
@@ -118,21 +118,19 @@
   }
 }
 
-// Compile our __lldb_backtrace_recording_get_item_info() function (from the
-// source above in g_get_item_info_function_code) if we don't find that function
-// in the inferior
-// already with USE_BUILTIN_FUNCTION defined.  (e.g. this would be the case for
-// testing.)
+// Compile our __lldb_backtrace_recording_get_item_info() function (from
+// the source above in g_get_item_info_function_code) if we don't find
+// that function in the inferior already with USE_BUILTIN_FUNCTION
+// defined.  (e.g. this would be the case for testing.)
 //
-// Insert the __lldb_backtrace_recording_get_item_info into the inferior process
-// if needed.
+// Insert the __lldb_backtrace_recording_get_item_info into the inferior
+// process if needed.
 //
-// Write the get_item_info_arglist into the inferior's memory space to prepare
-// for the call.
+// Write the get_item_info_arglist into the inferior's memory space to
+// prepare for the call.
 //
-// Returns the address of the arguments written down in the inferior process,
-// which can be used to
-// make the function call.
+// Returns the address of the arguments written down in the inferior
+// process, which can be used to make the function call.
 
 lldb::addr_t AppleGetItemInfoHandler::SetupGetItemInfoFunction(
     Thread &thread, ValueList &get_item_info_arglist) {
@@ -146,7 +144,8 @@
   {
     std::lock_guard<std::mutex> guard(m_get_item_info_function_mutex);
 
-    // First stage is to make the UtilityFunction to hold our injected function:
+    // First stage is to make the UtilityFunction to hold our injected
+    // function:
 
     if (!m_get_item_info_impl_code.get()) {
       if (g_get_item_info_function_code != NULL) {
@@ -176,7 +175,8 @@
         return LLDB_INVALID_ADDRESS;
       }
 
-      // Next make the runner function for our implementation utility function.
+      // Next make the runner function for our implementation utility
+      // function.
       Status error;
 
       TypeSystem *type_system =
@@ -208,11 +208,11 @@
 
   diagnostics.Clear();
 
-  // Now write down the argument values for this particular call.  This looks
-  // like it might be a race condition
-  // if other threads were calling into here, but actually it isn't because we
-  // allocate a new args structure for
-  // this call by passing args_addr = LLDB_INVALID_ADDRESS...
+  // Now write down the argument values for this particular call.  This
+  // looks like it might be a race condition if other threads were calling
+  // into here, but actually it isn't because we allocate a new args
+  // structure for this call by passing args_addr =
+  // LLDB_INVALID_ADDRESS...
 
   if (!get_item_info_caller->WriteFunctionArguments(
           exe_ctx, args_addr, get_item_info_arglist, diagnostics)) {
@@ -272,8 +272,7 @@
   //                                             uint64_t page_to_free_size)
 
   // Where the return_buffer argument points to a 24 byte region of memory
-  // already allocated by lldb in
-  // the inferior process.
+  // already allocated by lldb in the inferior process.
 
   CompilerType clang_void_ptr_type =
       clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
Index: source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp
===================================================================
--- source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp
+++ source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp
@@ -121,21 +121,20 @@
   }
 }
 
-// Compile our __lldb_backtrace_recording_get_pending_items() function (from the
-// source above in g_get_pending_items_function_code) if we don't find that
-// function in the inferior
-// already with USE_BUILTIN_FUNCTION defined.  (e.g. this would be the case for
+// Compile our __lldb_backtrace_recording_get_pending_items() function
+// (from the source above in g_get_pending_items_function_code) if we
+// don't find that function in the inferior already with
+// USE_BUILTIN_FUNCTION defined.  (e.g. this would be the case for
 // testing.)
 //
-// Insert the __lldb_backtrace_recording_get_pending_items into the inferior
-// process if needed.
+// Insert the __lldb_backtrace_recording_get_pending_items into the
+// inferior process if needed.
 //
 // Write the get_pending_items_arglist into the inferior's memory space to
 // prepare for the call.
 //
-// Returns the address of the arguments written down in the inferior process,
-// which can be used to
-// make the function call.
+// Returns the address of the arguments written down in the inferior
+// process, which can be used to make the function call.
 
 lldb::addr_t AppleGetPendingItemsHandler::SetupGetPendingItemsFunction(
     Thread &thread, ValueList &get_pending_items_arglist) {
@@ -151,7 +150,8 @@
   {
     std::lock_guard<std::mutex> guard(m_get_pending_items_function_mutex);
 
-    // First stage is to make the ClangUtility to hold our injected function:
+    // First stage is to make the ClangUtility to hold our injected
+    // function:
 
     if (!m_get_pending_items_impl_code.get()) {
       if (g_get_pending_items_function_code != NULL) {
@@ -182,7 +182,8 @@
         return LLDB_INVALID_ADDRESS;
       }
 
-      // Next make the runner function for our implementation utility function.
+      // Next make the runner function for our implementation utility
+      // function.
       Status error;
       ClangASTContext *clang_ast_context =
           thread.GetProcess()->GetTarget().GetScratchClangASTContext();
@@ -211,11 +212,11 @@
     return LLDB_INVALID_ADDRESS;
   }
 
-  // Now write down the argument values for this particular call.  This looks
-  // like it might be a race condition
-  // if other threads were calling into here, but actually it isn't because we
-  // allocate a new args structure for
-  // this call by passing args_addr = LLDB_INVALID_ADDRESS...
+  // Now write down the argument values for this particular call.  This
+  // looks like it might be a race condition if other threads were calling
+  // into here, but actually it isn't because we allocate a new args
+  // structure for this call by passing args_addr =
+  // LLDB_INVALID_ADDRESS...
 
   if (!get_pending_items_caller->WriteFunctionArguments(
           exe_ctx, args_addr, get_pending_items_arglist, diagnostics)) {
@@ -279,8 +280,7 @@
   //                                             uint64_t page_to_free_size)
 
   // Where the return_buffer argument points to a 24 byte region of memory
-  // already allocated by lldb in
-  // the inferior process.
+  // already allocated by lldb in the inferior process.
 
   CompilerType clang_void_ptr_type =
       clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
Index: source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp
===================================================================
--- source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp
+++ source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp
@@ -118,9 +118,9 @@
 }
 
 // Construct a CompilerType for the structure that
-// g_get_current_queues_function_code will return by value
-// so we can extract the fields after performing the function call.
-// i.e. we are getting this struct returned to us:
+// g_get_current_queues_function_code will return by value so we can
+// extract the fields after performing the function call. i.e. we are
+// getting this struct returned to us:
 //
 //    struct get_current_queues_return_values
 //    {
@@ -129,22 +129,20 @@
 //        uint64_t count;
 //    };
 
-// Compile our __lldb_backtrace_recording_get_current_queues() function (from
-// the
-// source above in g_get_current_queues_function_code) if we don't find that
-// function in the inferior
-// already with USE_BUILTIN_FUNCTION defined.  (e.g. this would be the case for
+// Compile our __lldb_backtrace_recording_get_current_queues() function
+// (from the source above in g_get_current_queues_function_code) if we
+// don't find that function in the inferior already with
+// USE_BUILTIN_FUNCTION defined.  (e.g. this would be the case for
 // testing.)
 //
-// Insert the __lldb_backtrace_recording_get_current_queues into the inferior
-// process if needed.
+// Insert the __lldb_backtrace_recording_get_current_queues into the
+// inferior process if needed.
 //
-// Write the get_queues_arglist into the inferior's memory space to prepare for
-// the call.
+// Write the get_queues_arglist into the inferior's memory space to
+// prepare for the call.
 //
-// Returns the address of the arguments written down in the inferior process,
-// which can be used to
-// make the function call.
+// Returns the address of the arguments written down in the inferior
+// process, which can be used to make the function call.
 
 lldb::addr_t
 AppleGetQueuesHandler::SetupGetQueuesFunction(Thread &thread,
@@ -163,7 +161,8 @@
   {
     std::lock_guard<std::mutex> guard(m_get_queues_function_mutex);
 
-    // First stage is to make the ClangUtility to hold our injected function:
+    // First stage is to make the ClangUtility to hold our injected
+    // function:
 
     if (!m_get_queues_impl_code_up.get()) {
       if (g_get_current_queues_function_code != NULL) {
@@ -197,7 +196,8 @@
       }
     }
 
-    // Next make the runner function for our implementation utility function.
+    // Next make the runner function for our implementation utility
+    // function.
     ClangASTContext *clang_ast_context =
         thread.GetProcess()->GetTarget().GetScratchClangASTContext();
     CompilerType get_queues_return_type =
@@ -216,11 +216,11 @@
 
   diagnostics.Clear();
 
-  // Now write down the argument values for this particular call.  This looks
-  // like it might be a race condition
-  // if other threads were calling into here, but actually it isn't because we
-  // allocate a new args structure for
-  // this call by passing args_addr = LLDB_INVALID_ADDRESS...
+  // Now write down the argument values for this particular call.  This
+  // looks like it might be a race condition if other threads were calling
+  // into here, but actually it isn't because we allocate a new args
+  // structure for this call by passing args_addr =
+  // LLDB_INVALID_ADDRESS...
 
   if (!get_queues_caller->WriteFunctionArguments(
           exe_ctx, args_addr, get_queues_arglist, diagnostics)) {
@@ -280,8 +280,7 @@
   //                                          uint64_t page_to_free_size);
 
   // Where the return_buffer argument points to a 24 byte region of memory
-  // already allocated by lldb in
-  // the inferior process.
+  // already allocated by lldb in the inferior process.
 
   CompilerType clang_void_ptr_type =
       clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
Index: source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.cpp
===================================================================
--- source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.cpp
+++ source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.cpp
@@ -127,22 +127,20 @@
   }
 }
 
-// Compile our __lldb_backtrace_recording_get_thread_item_info() function (from
-// the
-// source above in g_get_thread_item_info_function_code) if we don't find that
-// function in the inferior
-// already with USE_BUILTIN_FUNCTION defined.  (e.g. this would be the case for
+// Compile our __lldb_backtrace_recording_get_thread_item_info() function
+// (from the source above in g_get_thread_item_info_function_code) if we
+// don't find that function in the inferior already with
+// USE_BUILTIN_FUNCTION defined.  (e.g. this would be the case for
 // testing.)
 //
-// Insert the __lldb_backtrace_recording_get_thread_item_info into the inferior
-// process if needed.
+// Insert the __lldb_backtrace_recording_get_thread_item_info into the
+// inferior process if needed.
 //
-// Write the get_thread_item_info_arglist into the inferior's memory space to
-// prepare for the call.
+// Write the get_thread_item_info_arglist into the inferior's memory space
+// to prepare for the call.
 //
-// Returns the address of the arguments written down in the inferior process,
-// which can be used to
-// make the function call.
+// Returns the address of the arguments written down in the inferior
+// process, which can be used to make the function call.
 
 lldb::addr_t AppleGetThreadItemInfoHandler::SetupGetThreadItemInfoFunction(
     Thread &thread, ValueList &get_thread_item_info_arglist) {
@@ -158,7 +156,8 @@
   {
     std::lock_guard<std::mutex> guard(m_get_thread_item_info_function_mutex);
 
-    // First stage is to make the ClangUtility to hold our injected function:
+    // First stage is to make the ClangUtility to hold our injected
+    // function:
 
     if (!m_get_thread_item_info_impl_code.get()) {
       Status error;
@@ -220,11 +219,11 @@
 
   diagnostics.Clear();
 
-  // Now write down the argument values for this particular call.  This looks
-  // like it might be a race condition
-  // if other threads were calling into here, but actually it isn't because we
-  // allocate a new args structure for
-  // this call by passing args_addr = LLDB_INVALID_ADDRESS...
+  // Now write down the argument values for this particular call.  This
+  // looks like it might be a race condition if other threads were calling
+  // into here, but actually it isn't because we allocate a new args
+  // structure for this call by passing args_addr =
+  // LLDB_INVALID_ADDRESS...
 
   if (!get_thread_item_info_caller->WriteFunctionArguments(
           exe_ctx, args_addr, get_thread_item_info_arglist, diagnostics)) {
@@ -266,8 +265,7 @@
 
   // Set up the arguments for a call to
 
-  // struct get_thread_item_info_return_values
-  // {
+  // struct get_thread_item_info_return_values {
   //     uint64_t item_info_buffer_ptr;    /* the address of the items buffer
   //     from libBacktraceRecording */
   //     uint64_t item_info_buffer_size;   /* the size of the items buffer from
@@ -283,8 +281,7 @@
   //                                             uint64_t page_to_free_size)
 
   // Where the return_buffer argument points to a 24 byte region of memory
-  // already allocated by lldb in
-  // the inferior process.
+  // already allocated by lldb in the inferior process.
 
   CompilerType clang_void_ptr_type =
       clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
Index: source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp
===================================================================
--- source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp
+++ source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp
@@ -34,9 +34,9 @@
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
-// Create an instance of this class. This function is filled into
-// the plugin info class that gets handed out by the plugin factory and
-// allows the lldb to instantiate an instance of this class.
+// Create an instance of this class. This function is filled into the
+// plugin info class that gets handed out by the plugin factory and allows
+// the lldb to instantiate an instance of this class.
 //----------------------------------------------------------------------
 SystemRuntime *SystemRuntimeMacOSX::CreateInstance(Process *process) {
   bool create = false;
@@ -124,11 +124,9 @@
 
   ReadLibdispatchOffsets();
   if (m_libdispatch_offsets.IsValid()) {
-    // dispatch_qaddr is from a thread_info(THREAD_IDENTIFIER_INFO) call for a
-    // thread -
-    // deref it to get the address of the dispatch_queue_t structure for this
-    // thread's
-    // queue.
+    // dispatch_qaddr is from a thread_info(THREAD_IDENTIFIER_INFO) call
+    // for a thread - deref it to get the address of the dispatch_queue_t
+    // structure for this thread's queue.
     Status error;
     addr_t dispatch_queue_addr =
         m_process->ReadPointerFromMemory(dispatch_qaddr, error);
@@ -145,8 +143,8 @@
                                            error);
         }
       } else {
-        // libdispatch versions 1-3, dispatch name is a fixed width char array
-        // in the queue structure.
+        // libdispatch versions 1-3, dispatch name is a fixed width char
+        // array in the queue structure.
         addr_t label_addr =
             dispatch_queue_addr + m_libdispatch_offsets.dqo_label;
         dispatch_queue_name.resize(m_libdispatch_offsets.dqo_label_size, '\0');
@@ -247,11 +245,9 @@
 
   ReadLibdispatchOffsets();
   if (m_libdispatch_offsets.IsValid()) {
-    // dispatch_qaddr is from a thread_info(THREAD_IDENTIFIER_INFO) call for a
-    // thread -
-    // deref it to get the address of the dispatch_queue_t structure for this
-    // thread's
-    // queue.
+    // dispatch_qaddr is from a thread_info(THREAD_IDENTIFIER_INFO) call
+    // for a thread - deref it to get the address of the dispatch_queue_t
+    // structure for this thread's queue.
     Status error;
     uint64_t dispatch_queue_addr =
         m_process->ReadPointerFromMemory(dispatch_qaddr, error);
@@ -278,8 +274,8 @@
       "dispatch_queue_offsets");
   const Symbol *dispatch_queue_offsets_symbol = NULL;
 
-  // libdispatch symbols were in libSystem.B.dylib up through Mac OS X 10.6
-  // ("Snow Leopard")
+  // libdispatch symbols were in libSystem.B.dylib up through Mac OS X
+  // 10.6 ("Snow Leopard")
   ModuleSpec libSystem_module_spec(FileSpec("libSystem.B.dylib", false));
   ModuleSP module_sp(m_process->GetTarget().GetImages().FindFirstModule(
       libSystem_module_spec));
@@ -287,8 +283,8 @@
     dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType(
         g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
 
-  // libdispatch symbols are in their own dylib as of Mac OS X 10.7 ("Lion") and
-  // later
+  // libdispatch symbols are in their own dylib as of Mac OS X 10.7
+  // ("Lion") and later
   if (dispatch_queue_offsets_symbol == NULL) {
     ModuleSpec libdispatch_module_spec(FileSpec("libdispatch.dylib", false));
     module_sp = m_process->GetTarget().GetImages().FindFirstModule(
@@ -319,9 +315,8 @@
                             error) == sizeof(memory_buffer)) {
     lldb::offset_t data_offset = 0;
 
-    // The struct LibdispatchOffsets is a series of uint16_t's - extract them
-    // all
-    // in one big go.
+    // The struct LibdispatchOffsets is a series of uint16_t's - extract
+    // them all in one big go.
     data.GetU16(&data_offset, &m_libdispatch_offsets.dqo_version,
                 sizeof(struct LibdispatchOffsets) / sizeof(uint16_t));
   }
@@ -367,9 +362,8 @@
                               error) == sizeof(memory_buffer)) {
       lldb::offset_t data_offset = 0;
 
-      // The struct LibpthreadOffsets is a series of uint16_t's - extract them
-      // all
-      // in one big go.
+      // The struct LibpthreadOffsets is a series of uint16_t's - extract
+      // them all in one big go.
       data.GetU16(&data_offset, &m_libpthread_offsets.plo_version,
                   sizeof(struct LibpthreadOffsets) / sizeof(uint16_t));
     }
@@ -406,11 +400,9 @@
 
   if (m_dispatch_tsd_indexes_addr != LLDB_INVALID_ADDRESS) {
 
-// We don't need to check the version number right now, it will be at least 2,
-// but
-// keep this code around to fetch just the version # for the future where we
-// need
-// to fetch alternate versions of the struct.
+// We don't need to check the version number right now, it will be at
+// least 2, but keep this code around to fetch just the version # for the
+// future where we need to fetch alternate versions of the struct.
 #if 0
         uint16_t dti_version = 2;
         Address dti_struct_addr;
@@ -472,13 +464,11 @@
       type == ConstString("libdispatch")) {
     Status error;
 
-    // real_thread is either an actual, live thread (in which case we need to
-    // call into
-    // libBacktraceRecording to find its originator) or it is an extended
-    // backtrace itself,
-    // in which case we get the token from it and call into
-    // libBacktraceRecording to find
-    // the originator of that token.
+    // real_thread is either an actual, live thread (in which case we need
+    // to call into libBacktraceRecording to find its originator) or it is
+    // an extended backtrace itself, in which case we get the token from
+    // it and call into libBacktraceRecording to find the originator of
+    // that token.
 
     if (real_thread->GetExtendedBacktraceToken() != LLDB_INVALID_ADDRESS) {
       originating_thread_sp = GetExtendedBacktraceFromItemRef(
@@ -702,8 +692,9 @@
 SystemRuntimeMacOSX::GetExtendedBacktraceTypes() {
   if (m_types.size() == 0) {
     m_types.push_back(ConstString("libdispatch"));
-    // We could have pthread as another type in the future if we have a way of
-    // gathering that information & it's useful to distinguish between them.
+    // We could have pthread as another type in the future if we have a
+    // way of gathering that information & it's useful to distinguish
+    // between them.
   }
   return m_types;
 }
@@ -734,14 +725,12 @@
     }
   }
 
-  // We either didn't have libBacktraceRecording (and need to create the queues
-  // list based on threads)
-  // or we did get the queues list from libBacktraceRecording but some special
-  // queues may not be
-  // included in its information.  This is needed because libBacktraceRecording
-  // will only list queues with pending or running items by default - but the
-  // magic com.apple.main-thread
-  // queue on thread 1 is always around.
+  // We either didn't have libBacktraceRecording (and need to create the
+  // queues list based on threads) or we did get the queues list from
+  // libBacktraceRecording but some special queues may not be included in
+  // its information.  This is needed because libBacktraceRecording will
+  // only list queues with pending or running items by default - but the
+  // magic com.apple.main-thread queue on thread 1 is always around.
 
   for (ThreadSP thread_sp : m_process->Threads()) {
     if (thread_sp->GetAssociatedWithLibdispatchQueue() != eLazyBoolNo) {
@@ -768,13 +757,12 @@
   }
 }
 
-// Returns either an array of introspection_dispatch_item_info_ref's for the
-// pending items on
-// a queue or an array introspection_dispatch_item_info_ref's and code addresses
-// for the
-// pending items on a queue.  The information about each of these pending items
-// then needs to
-// be fetched individually by passing the ref to libBacktraceRecording.
+// Returns either an array of introspection_dispatch_item_info_ref's for
+// the pending items on a queue or an array
+// introspection_dispatch_item_info_ref's and code addresses for the
+// pending items on a queue.  The information about each of these pending
+// items then needs to be fetched individually by passing the ref to
+// libBacktraceRecording.
 
 SystemRuntimeMacOSX::PendingItemsForQueue
 SystemRuntimeMacOSX::GetPendingItemRefsForQueue(lldb::addr_t queue) {
@@ -916,8 +904,8 @@
   if (m_process->ReadMemory(queues_buffer, data.GetBytes(), queues_buffer_size,
                             error) == queues_buffer_size &&
       error.Success()) {
-    // We've read the information out of inferior memory; free it on the next
-    // call we make
+    // We've read the information out of inferior memory; free it on the
+    // next call we make
     m_page_to_free = queues_buffer;
     m_page_to_free_size = queues_buffer_size;
 
Index: source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp
===================================================================
--- source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp
+++ source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp
@@ -90,9 +90,9 @@
       m_register_values.clear();
       m_pushed_regs.clear();
 
-      // Initialize the CFA with a known value. In the 32 bit case
-      // it will be 0x80000000, and in the 64 bit case 0x8000000000000000.
-      // We use the address byte size to be safe for any future address sizes
+      // Initialize the CFA with a known value. In the 32 bit case it will
+      // be 0x80000000, and in the 64 bit case 0x8000000000000000. We use
+      // the address byte size to be safe for any future address sizes
       m_initial_sp = (1ull << ((addr_byte_size * 8) - 1));
       RegisterValue cfa_reg_value;
       cfa_reg_value.SetUInt(m_initial_sp, m_cfa_reg_info.byte_size);
@@ -105,19 +105,18 @@
         Instruction *inst = inst_list.GetInstructionAtIndex(0).get();
         const lldb::addr_t base_addr = inst->GetAddress().GetFileAddress();
 
-        // Map for storing the unwind plan row and the value of the registers at
-        // a given offset.
-        // When we see a forward branch we add a new entry to this map with the
-        // actual unwind plan
-        // row and register context for the target address of the branch as the
-        // current data have
-        // to be valid for the target address of the branch too if we are in the
-        // same function.
+        // Map for storing the unwind plan row and the value of the
+        // registers at a given offset. When we see a forward branch we
+        // add a new entry to this map with the actual unwind plan row and
+        // register context for the target address of the branch as the
+        // current data have to be valid for the target address of the
+        // branch too if we are in the same function.
         std::map<lldb::addr_t, std::pair<UnwindPlan::RowSP, RegisterValueMap>>
             saved_unwind_states;
 
-        // Make a copy of the current instruction Row and save it in m_curr_row
-        // so we can add updates as we process the instructions.
+        // Make a copy of the current instruction Row and save it in
+        // m_curr_row so we can add updates as we process the
+        // instructions.
         UnwindPlan::RowSP last_row = unwind_plan.GetLastRow();
         UnwindPlan::Row *newrow = new UnwindPlan::Row;
         if (last_row.get())
@@ -127,16 +126,16 @@
         // Add the initial state to the save list with offset 0.
         saved_unwind_states.insert({0, {last_row, m_register_values}});
 
-        // cache the pc register number (in whatever register numbering this
-        // UnwindPlan uses) for
-        // quick reference during instruction parsing.
+        // cache the pc register number (in whatever register numbering
+        // this UnwindPlan uses) for quick reference during instruction
+        // parsing.
         RegisterInfo pc_reg_info;
         m_inst_emulator_ap->GetRegisterInfo(
             eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, pc_reg_info);
 
         // cache the return address register number (in whatever register
-        // numbering this UnwindPlan uses) for
-        // quick reference during instruction parsing.
+        // numbering this UnwindPlan uses) for quick reference during
+        // instruction parsing.
         RegisterInfo ra_reg_info;
         m_inst_emulator_ap->GetRegisterInfo(
             eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA, ra_reg_info);
@@ -160,12 +159,11 @@
                    "Unwind row for the function entry missing");
             --it; // Move it to the row corresponding to the current offset
 
-            // If the offset of m_curr_row don't match with the offset we see in
-            // saved_unwind_states
-            // then we have to update m_curr_row and m_register_values based on
-            // the saved values. It
-            // is happenning after we processed an epilogue and a return to
-            // caller instruction.
+            // If the offset of m_curr_row don't match with the offset we
+            // see in saved_unwind_states then we have to update
+            // m_curr_row and m_register_values based on the saved values.
+            // It is happenning after we processed an epilogue and a
+            // return to caller instruction.
             if (it->second.first->GetOffset() != m_curr_row->GetOffset()) {
               UnwindPlan::Row *newrow = new UnwindPlan::Row;
               *newrow = *it->second.first;
@@ -181,10 +179,9 @@
               if (m_inst_emulator_ap->GetInstructionCondition() !=
                       EmulateInstruction::UnconditionalCondition &&
                   saved_unwind_states.count(current_offset) == 0) {
-                // If we don't have a saved row for the current offset then save
-                // our
-                // current state because we will have to restore it after the
-                // conditional block.
+                // If we don't have a saved row for the current offset
+                // then save our current state because we will have to
+                // restore it after the conditional block.
                 auto new_row =
                     std::make_shared<UnwindPlan::Row>(*m_curr_row.get());
                 saved_unwind_states.insert(
@@ -192,8 +189,8 @@
               }
 
               // If the last instruction was conditional with a different
-              // condition
-              // then the then current condition then restore the condition.
+              // condition then the then current condition then restore
+              // the condition.
               if (last_condition !=
                   EmulateInstruction::UnconditionalCondition) {
                 const auto &saved_state =
@@ -211,7 +208,8 @@
                     replace_existing);
               }
 
-              // We are starting a new conditional block at the catual offset
+              // We are starting a new conditional block at the catual
+              // offset
               condition_block_start_offset = current_offset;
             }
 
@@ -229,9 +227,9 @@
             m_inst_emulator_ap->EvaluateInstruction(
                 eEmulateInstructionOptionIgnoreConditions);
 
-            // If the current instruction is a branch forward then save the
-            // current CFI information
-            // for the offset where we are branching.
+            // If the current instruction is a branch forward then save
+            // the current CFI information for the offset where we are
+            // branching.
             if (m_forward_branch_offset != 0 &&
                 range.ContainsFileAddress(inst->GetAddress().GetFileAddress() +
                                           m_forward_branch_offset)) {
@@ -247,8 +245,8 @@
             // Were there any changes to the CFI while evaluating this
             // instruction?
             if (m_curr_row_modified) {
-              // Save the modified row if we don't already have a CFI row in the
-              // currennt address
+              // Save the modified row if we don't already have a CFI row
+              // in the currennt address
               if (saved_unwind_states.count(
                       current_offset + inst->GetOpcode().GetByteSize()) == 0) {
                 m_curr_row->SetOffset(current_offset +
@@ -258,8 +256,8 @@
                     {current_offset + inst->GetOpcode().GetByteSize(),
                      {m_curr_row, m_register_values}});
 
-                // Allocate a new Row for m_curr_row, copy the current state
-                // into it
+                // Allocate a new Row for m_curr_row, copy the current
+                // state into it
                 UnwindPlan::Row *newrow = new UnwindPlan::Row;
                 *newrow = *m_curr_row.get();
                 m_curr_row.reset(newrow);
@@ -558,9 +556,8 @@
     break;
 
   case EmulateInstruction::eContextArithmetic: {
-    // If we adjusted the current frame pointer by a constant then adjust the
-    // CFA offset
-    // with the same amount.
+    // If we adjusted the current frame pointer by a constant then adjust
+    // the CFA offset with the same amount.
     lldb::RegisterKind kind = m_unwind_plan_ptr->GetRegisterKind();
     if (m_fp_is_cfa && reg_info->kinds[kind] == m_cfa_reg_info.kinds[kind] &&
         context.info_type == EmulateInstruction::eInfoTypeRegisterPlusOffset &&
Index: source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp
===================================================================
--- source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp
+++ source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp
@@ -85,12 +85,10 @@
   RegisterNumber pc_regnum(thread, eRegisterKindGeneric,
                            LLDB_REGNUM_GENERIC_PC);
 
-  // Does this UnwindPlan describe the prologue?  I want to see that the CFA is
-  // set
-  // in terms of the stack pointer plus an offset, and I want to see that rip is
-  // retrieved at the CFA-wordsize.
-  // If there is no description of the prologue, don't try to augment this
-  // eh_frame
+  // Does this UnwindPlan describe the prologue?  I want to see that the
+  // CFA is set in terms of the stack pointer plus an offset, and I want
+  // to see that rip is retrieved at the CFA-wordsize. If there is no
+  // description of the prologue, don't try to augment this eh_frame
   // unwinder code, fall back to assembly parsing instead.
 
   if (first_row->GetCFAValue().GetValueType() !=
@@ -110,17 +108,16 @@
     return false;
   }
 
-  // It looks like the prologue is described.
-  // Is the epilogue described?  If it is, no need to do any augmentation.
+  // It looks like the prologue is described. Is the epilogue described?
+  // If it is, no need to do any augmentation.
 
   if (first_row != last_row &&
       first_row->GetOffset() != last_row->GetOffset()) {
-    // The first & last row have the same CFA register
-    // and the same CFA offset value
-    // and the CFA register is esp/rsp (the stack pointer).
+    // The first & last row have the same CFA register and the same CFA
+    // offset value and the CFA register is esp/rsp (the stack pointer).
 
-    // We're checking that both of them have an unwind rule like "CFA=esp+4" or
-    // CFA+rsp+8".
+    // We're checking that both of them have an unwind rule like
+    // "CFA=esp+4" or CFA+rsp+8".
 
     if (first_row->GetCFAValue().GetValueType() ==
             last_row->GetCFAValue().GetValueType() &&
@@ -128,8 +125,8 @@
             last_row->GetCFAValue().GetRegisterNumber() &&
         first_row->GetCFAValue().GetOffset() ==
             last_row->GetCFAValue().GetOffset()) {
-      // Get the register locations for eip/rip from the first & last rows.
-      // Are they both CFA plus an offset?  Is it the same offset?
+      // Get the register locations for eip/rip from the first & last
+      // rows. Are they both CFA plus an offset?  Is it the same offset?
 
       UnwindPlan::Row::RegisterLocation last_row_pc_loc;
       if (last_row->GetRegisterInfo(
@@ -138,13 +135,11 @@
         if (last_row_pc_loc.IsAtCFAPlusOffset() &&
             first_row_pc_loc.GetOffset() == last_row_pc_loc.GetOffset()) {
 
-          // One last sanity check:  Is the unwind rule for getting the caller
-          // pc value
-          // "deref the CFA-4" or "deref the CFA-8"?
+          // One last sanity check:  Is the unwind rule for getting the
+          // caller pc value "deref the CFA-4" or "deref the CFA-8"?
 
-          // If so, we have an UnwindPlan that already describes the epilogue
-          // and we don't need
-          // to modify it at all.
+          // If so, we have an UnwindPlan that already describes the
+          // epilogue and we don't need to modify it at all.
 
           if (first_row_pc_loc.GetOffset() == -wordsize) {
             do_augment_unwindplan = false;
@@ -184,7 +179,8 @@
   //   55        pushq %rbp
   //   48 89 e5  movq %rsp, %rbp
 
-  // We should pull in the ABI architecture default unwind plan and return that
+  // We should pull in the ABI architecture default unwind plan and return
+  // that
 
   llvm::SmallVector<uint8_t, 4> opcode_data;
 
Index: source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp
===================================================================
--- source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp
+++ source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp
@@ -245,9 +245,8 @@
   m_register_map_initialized = true;
 }
 
-// This function expects an x86 native register number (i.e. the bits stripped
-// out of the
-// actual instruction), not an lldb register number.
+// This function expects an x86 native register number (i.e. the bits
+// stripped out of the actual instruction), not an lldb register number.
 //
 // FIXME: This is ABI dependent, it shouldn't be hardcoded here.
 
@@ -286,12 +285,12 @@
 // Macro to detect if this is a REX mode prefix byte.
 #define REX_W_PREFIX_P(opcode) (((opcode) & (~0x5)) == 0x48)
 
-// The high bit which should be added to the source register number (the "R"
-// bit)
+// The high bit which should be added to the source register number (the
+// "R" bit)
 #define REX_W_SRCREG(opcode) (((opcode)&0x4) >> 2)
 
-// The high bit which should be added to the destination register number (the
-// "B" bit)
+// The high bit which should be added to the destination register number
+// (the "B" bit)
 #define REX_W_DSTREG(opcode) ((opcode)&0x1)
 
 // pushq %rbp [0x55]
@@ -321,15 +320,14 @@
 
 // pushl imm8(%esp)
 //
-// e.g. 0xff 0x74 0x24 0x20 - 'pushl 0x20(%esp)'
-// (same byte pattern for 'pushq 0x20(%rsp)' in an x86_64 program)
+// e.g. 0xff 0x74 0x24 0x20 - 'pushl 0x20(%esp)' (same byte pattern for
+// 'pushq 0x20(%rsp)' in an x86_64 program)
 //
-// 0xff (with opcode bits '6' in next byte, PUSH r/m32)
-// 0x74 (ModR/M byte with three bits used to specify the opcode)
+// 0xff (with opcode bits '6' in next byte, PUSH r/m32) 0x74 (ModR/M byte
+// with three bits used to specify the opcode)
 //      mod == b01, opcode == b110, R/M == b100
 //      "+disp8"
-// 0x24 (SIB byte - scaled index = 0, r32 == esp)
-// 0x20 imm8 value
+// 0x24 (SIB byte - scaled index = 0, r32 == esp) 0x20 imm8 value
 
 bool x86AssemblyInspectionEngine::push_extended_pattern_p() {
   if (*m_cur_insn == 0xff) {
@@ -337,9 +335,8 @@
     uint8_t opcode = (*(m_cur_insn + 1) >> 3) & 7;
     if (opcode == 6) {
       // I'm only looking for 0xff /6 here - I
-      // don't really care what value is being pushed,
-      // just that we're pushing a 32/64 bit value on
-      // to the stack is enough.
+      // don't really care what value is being pushed, just that we're
+      // pushing a 32/64 bit value on to the stack is enough.
       return true;
     }
   }
@@ -377,8 +374,8 @@
   return false;
 }
 
-// movq %rsp, %rbp [0x48 0x8b 0xec] or [0x48 0x89 0xe5]
-// movl %esp, %ebp [0x8b 0xec] or [0x89 0xe5]
+// movq %rsp, %rbp [0x48 0x8b 0xec] or [0x48 0x89 0xe5] movl %esp, %ebp
+// [0x8b 0xec] or [0x89 0xe5]
 bool x86AssemblyInspectionEngine::mov_rsp_rbp_pattern_p() {
   uint8_t *p = m_cur_insn;
   if (m_wordsize == 8 && *p == 0x48)
@@ -529,16 +526,16 @@
          (*(p + 3) == 0x0) && (*(p + 4) == 0x0);
 }
 
-// Look for an instruction sequence storing a nonvolatile register
-// on to the stack frame.
+// Look for an instruction sequence storing a nonvolatile register on to
+// the stack frame.
 
 //  movq %rax, -0x10(%rbp) [0x48 0x89 0x45 0xf0]
 //  movl %eax, -0xc(%ebp)  [0x89 0x45 0xf4]
 
-// The offset value returned in rbp_offset will be positive --
-// but it must be subtraced from the frame base register to get
-// the actual location.  The positive value returned for the offset
-// is a convention used elsewhere for CFA offsets et al.
+// The offset value returned in rbp_offset will be positive -- but it must
+// be subtraced from the frame base register to get the actual location.
+// The positive value returned for the offset is a convention used
+// elsewhere for CFA offsets et al.
 
 bool x86AssemblyInspectionEngine::mov_reg_to_local_stack_frame_p(
     int &regno, int &rbp_offset) {
@@ -550,8 +547,8 @@
     src_reg_prefix_bit = REX_W_SRCREG(*p) << 3;
     target_reg_prefix_bit = REX_W_DSTREG(*p) << 3;
     if (target_reg_prefix_bit == 1) {
-      // rbp/ebp don't need a prefix bit - we know this isn't the
-      // reg we care about.
+      // rbp/ebp don't need a prefix bit - we know this isn't the reg we
+      // care about.
       return false;
     }
     p++;
@@ -650,8 +647,8 @@
   unwind_plan.SetPlanValidAddressRange(func_range);
   unwind_plan.SetRegisterKind(eRegisterKindLLDB);
 
-  // At the start of the function, find the CFA by adding wordsize to the SP
-  // register
+  // At the start of the function, find the CFA by adding wordsize to the
+  // SP register
   row->SetOffset(current_func_text_offset);
   row->GetCFAValue().SetIsRegisterPlusOffset(m_lldb_sp_regnum, m_wordsize);
 
@@ -671,18 +668,16 @@
   *newrow = *row.get();
   row.reset(newrow);
 
-  // Track which registers have been saved so far in the prologue.
-  // If we see another push of that register, it's not part of the prologue.
-  // The register numbers used here are the machine register #'s
+  // Track which registers have been saved so far in the prologue. If we
+  // see another push of that register, it's not part of the prologue. The
+  // register numbers used here are the machine register #'s
   // (i386_register_numbers, x86_64_register_numbers).
   std::vector<bool> saved_registers(32, false);
 
   // Once the prologue has completed we'll save a copy of the unwind
-  // instructions
-  // If there is an epilogue in the middle of the function, after that epilogue
-  // we'll reinstate
-  // the unwind setup -- we assume that some code path jumps over the
-  // mid-function epilogue
+  // instructions If there is an epilogue in the middle of the function,
+  // after that epilogue we'll reinstate the unwind setup -- we assume
+  // that some code path jumps over the mid-function epilogue
 
   UnwindPlan::RowSP prologue_completed_row; // copy of prologue row of CFI
   int prologue_completed_sp_bytes_offset_from_cfa; // The sp value before the
@@ -722,26 +717,25 @@
       row_updated = true;
     }
 
-    // This is the start() function (or a pthread equivalent), it starts with a
-    // pushl $0x0 which puts the
-    // saved pc value of 0 on the stack.  In this case we want to pretend we
-    // didn't see a stack movement at all --
-    // normally the saved pc value is already on the stack by the time the
-    // function starts executing.
+    // This is the start() function (or a pthread equivalent), it starts
+    // with a pushl $0x0 which puts the saved pc value of 0 on the stack.
+    // In this case we want to pretend we didn't see a stack movement at
+    // all -- normally the saved pc value is already on the stack by the
+    // time the function starts executing.
     else if (push_0_pattern_p()) {
     }
 
     else if (push_reg_p(machine_regno)) {
       current_sp_bytes_offset_from_cfa += m_wordsize;
-      // the PUSH instruction has moved the stack pointer - if the CFA is set in
-      // terms of the stack pointer,
-      // we need to add a new row of instructions.
+      // the PUSH instruction has moved the stack pointer - if the CFA is
+      // set in terms of the stack pointer, we need to add a new row of
+      // instructions.
       if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum) {
         row->GetCFAValue().SetOffset(current_sp_bytes_offset_from_cfa);
         row_updated = true;
       }
-      // record where non-volatile (callee-saved, spilled) registers are saved
-      // on the stack
+      // record where non-volatile (callee-saved, spilled) registers are
+      // saved on the stack
       if (nonvolatile_reg_p(machine_regno) &&
           machine_regno_to_lldb_regno(machine_regno, lldb_regno) &&
           saved_registers[machine_regno] == false) {
@@ -771,9 +765,9 @@
         row_updated = true;
       }
 
-      // the POP instruction has moved the stack pointer - if the CFA is set in
-      // terms of the stack pointer,
-      // we need to add a new row of instructions.
+      // the POP instruction has moved the stack pointer - if the CFA is
+      // set in terms of the stack pointer, we need to add a new row of
+      // instructions.
       if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum) {
         row->GetCFAValue().SetIsRegisterPlusOffset(
             m_lldb_sp_regnum, current_sp_bytes_offset_from_cfa);
@@ -790,13 +784,13 @@
       }
     }
 
-    // The LEAVE instruction moves the value from rbp into rsp and pops
-    // a value off the stack into rbp (restoring the caller's rbp value).
-    // It is the opposite of ENTER, or 'push rbp, mov rsp rbp'.
+    // The LEAVE instruction moves the value from rbp into rsp and pops a
+    // value off the stack into rbp (restoring the caller's rbp value). It
+    // is the opposite of ENTER, or 'push rbp, mov rsp rbp'.
     else if (leave_pattern_p()) {
-      // We're going to copy the value in rbp into rsp, so re-set the sp offset
-      // based on the CFAValue.  Also, adjust it to recognize that we're popping
-      // the saved rbp value off the stack.
+      // We're going to copy the value in rbp into rsp, so re-set the sp
+      // offset based on the CFAValue.  Also, adjust it to recognize that
+      // we're popping the saved rbp value off the stack.
       current_sp_bytes_offset_from_cfa = row->GetCFAValue().GetOffset();
       current_sp_bytes_offset_from_cfa -= m_wordsize;
       row->GetCFAValue().SetOffset(current_sp_bytes_offset_from_cfa);
@@ -822,12 +816,11 @@
 
       UnwindPlan::Row::RegisterLocation regloc;
 
-      // stack_offset for 'movq %r15, -80(%rbp)' will be 80.
-      // In the Row, we want to express this as the offset from the CFA.  If the
-      // frame base
-      // is rbp (like the above instruction), the CFA offset for rbp is probably
-      // 16.  So we
-      // want to say that the value is stored at the CFA address - 96.
+      // stack_offset for 'movq %r15, -80(%rbp)' will be 80. In the Row,
+      // we want to express this as the offset from the CFA.  If the frame
+      // base is rbp (like the above instruction), the CFA offset for rbp
+      // is probably 16.  So we want to say that the value is stored at
+      // the CFA address - 96.
       regloc.SetAtCFAPlusOffset(
           -(stack_offset + row->GetCFAValue().GetOffset()));
 
@@ -879,8 +872,8 @@
     }
 
     else if (ret_pattern_p() && prologue_completed_row.get()) {
-      // Reinstate the saved prologue setup for any instructions
-      // that come after the ret instruction
+      // Reinstate the saved prologue setup for any instructions that come
+      // after the ret instruction
 
       UnwindPlan::Row *newrow = new UnwindPlan::Row;
       *newrow = *prologue_completed_row.get();
@@ -901,8 +894,8 @@
     // call next instruction
     //     call 0
     //  => pop  %ebx
-    // This is used in i386 programs to get the PIC base address for finding
-    // global data
+    // This is used in i386 programs to get the PIC base address for
+    // finding global data
     else if (call_next_insn_pattern_p()) {
       current_sp_bytes_offset_from_cfa += m_wordsize;
       if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum) {
@@ -935,8 +928,8 @@
       }
     }
 
-    // We may change the sp value without adding a new Row necessarily -- keep
-    // track of it either way.
+    // We may change the sp value without adding a new Row necessarily --
+    // keep track of it either way.
     if (in_epilogue == false) {
       prologue_completed_sp_bytes_offset_from_cfa =
           current_sp_bytes_offset_from_cfa;
@@ -960,16 +953,15 @@
   if (!addr_start.IsValid())
     return false;
 
-  // We either need a live RegisterContext, or we need the UnwindPlan to already
-  // be in the lldb register numbering scheme.
+  // We either need a live RegisterContext, or we need the UnwindPlan to
+  // already be in the lldb register numbering scheme.
   if (reg_ctx.get() == nullptr &&
       unwind_plan.GetRegisterKind() != eRegisterKindLLDB)
     return false;
 
   // Is original unwind_plan valid?
-  // unwind_plan should have at least one row which is ABI-default (CFA register
-  // is sp),
-  // and another row in mid-function.
+  // unwind_plan should have at least one row which is ABI-default (CFA
+  // register is sp), and another row in mid-function.
   if (unwind_plan.GetRowCount() < 2)
     return false;
 
@@ -994,11 +986,9 @@
   UnwindPlan::RowSP row(new UnwindPlan::Row(*first_row));
   m_cur_insn = data + offset;
 
-  // After a mid-function epilogue we will need to re-insert the original unwind
-  // rules
-  // so unwinds work for the remainder of the function.  These aren't common
-  // with clang/gcc
-  // on x86 but it is possible.
+  // After a mid-function epilogue we will need to re-insert the original
+  // unwind rules so unwinds work for the remainder of the function.
+  // These aren't common with clang/gcc on x86 but it is possible.
   bool reinstate_unwind_state = false;
 
   while (offset < size) {
@@ -1015,8 +1005,7 @@
     offset += insn_len;
     m_cur_insn = data + offset;
 
-    // offset is pointing beyond the bounds of the
-    // function; stop looping.
+    // offset is pointing beyond the bounds of the function; stop looping.
     if (offset >= size) 
       continue;
 
@@ -1044,9 +1033,8 @@
     }
 
     if (row_id == 0) {
-      // If we are here, compiler didn't generate CFI for prologue.
-      // This won't happen to GCC or clang.
-      // In this case, bail out directly.
+      // If we are here, compiler didn't generate CFI for prologue. This
+      // won't happen to GCC or clang. In this case, bail out directly.
       return false;
     }
 
@@ -1086,10 +1074,9 @@
       }
       if (pop_reg_p(regno)) {
         // Technically, this might be a nonvolatile register recover in
-        // epilogue.
-        // We should reset RegisterInfo for the register.
-        // But in practice, previous rule for the register is still valid...
-        // So we ignore this case.
+        // epilogue. We should reset RegisterInfo for the register. But in
+        // practice, previous rule for the register is still valid... So
+        // we ignore this case.
 
         row->SetOffset(offset);
         row->GetCFAValue().IncOffset(-m_wordsize);
@@ -1220,8 +1207,8 @@
     if (!instruction_length(m_cur_insn, insn_len, size - offset) 
         || insn_len > kMaxInstructionByteSize 
         || insn_len == 0) {
-      // An error parsing the instruction, i.e. probably data/garbage - stop
-      // scanning
+      // An error parsing the instruction, i.e. probably data/garbage -
+      // stop scanning
       break;
     }
 
Index: source/Symbol/ArmUnwindInfo.cpp
===================================================================
--- source/Symbol/ArmUnwindInfo.cpp
+++ source/Symbol/ArmUnwindInfo.cpp
@@ -64,18 +64,17 @@
     m_exidx_entries.emplace_back(file_addr, addr, data);
   }
 
-  // Sort the entries in the exidx section. The entries should be sorted inside
-  // the section but
-  // some old compiler isn't sorted them.
+  // Sort the entries in the exidx section. The entries should be sorted
+  // inside the section but some old compiler isn't sorted them.
   std::sort(m_exidx_entries.begin(), m_exidx_entries.end());
 }
 
 ArmUnwindInfo::~ArmUnwindInfo() {}
 
 // Read a byte from the unwind instruction stream with the given offset.
-// Custom function is required because have to red in order of significance
-// within their containing
-// word (most significant byte first) and in increasing word address order.
+// Custom function is required because have to red in order of
+// significance within their containing word (most significant byte first)
+// and in increasing word address order.
 uint8_t ArmUnwindInfo::GetByteAtOffset(const uint32_t *data,
                                        uint16_t offset) const {
   uint32_t value = data[offset / 4];
@@ -142,7 +141,8 @@
       vsp += ((byte1 & 0x3f) << 2) + 4;
     } else if ((byte1 & 0xc0) == 0x40) {
       // 01xxxxxx
-      // vsp = vsp – (xxxxxx << 2) - 4. Covers range 0x04-0x100 inclusive
+      // vsp = vsp – (xxxxxx << 2) - 4. Covers range 0x04-0x100
+      // inclusive
       vsp -= ((byte1 & 0x3f) << 2) + 4;
     } else if ((byte1 & 0xf0) == 0x80) {
       if (byte_offset >= byte_count)
@@ -155,8 +155,8 @@
         return false;
       } else {
         // 1000iiii iiiiiiii (i not all 0)
-        // Pop up to 12 integer registers under masks {r15-r12}, {r11-r4} (see
-        // remark b)
+        // Pop up to 12 integer registers under masks {r15-r12}, {r11-r4}
+        // (see remark b)
         uint16_t regs = ((byte1 & 0x0f) << 8) | byte2;
         for (uint8_t i = 0; i < 12; ++i) {
           if (regs & (1 << i)) {
@@ -171,7 +171,8 @@
       return false;
     } else if ((byte1 & 0xff) == 0x9f) {
       // 10011111
-      // Reserved as prefix for Intel Wireless MMX register to register moves
+      // Reserved as prefix for Intel Wireless MMX register to register
+      // moves
       return false;
     } else if ((byte1 & 0xf0) == 0x90) {
       // 1001nnnn (nnnn != 13,15)
@@ -230,8 +231,8 @@
       vsp += 0x204 + (uleb128 << 2);
     } else if ((byte1 & 0xff) == 0xb3) {
       // 10110011 sssscccc
-      // Pop VFP double-precision registers D[ssss]-D[ssss+cccc] saved (as if)
-      // by FSTMFDX (see remark d)
+      // Pop VFP double-precision registers D[ssss]-D[ssss+cccc] saved (as
+      // if) by FSTMFDX (see remark d)
       if (byte_offset >= byte_count)
         return false;
 
@@ -276,8 +277,8 @@
       return false;
     } else if ((byte1 & 0xff) == 0xc8) {
       // 11001000 sssscccc
-      // Pop VFP double precision registers D[16+ssss]-D[16+ssss+cccc] saved (as
-      // if) by FSTMFDD (see remarks d,e)
+      // Pop VFP double precision registers D[16+ssss]-D[16+ssss+cccc]
+      // saved (as if) by FSTMFDD (see remarks d,e)
       if (byte_offset >= byte_count)
         return false;
 
@@ -290,8 +291,8 @@
       }
     } else if ((byte1 & 0xff) == 0xc9) {
       // 11001001 sssscccc
-      // Pop VFP double precision registers D[ssss]-D[ssss+cccc] saved (as if)
-      // by FSTMFDD (see remark d)
+      // Pop VFP double precision registers D[ssss]-D[ssss+cccc] saved (as
+      // if) by FSTMFDD (see remark d)
       if (byte_offset >= byte_count)
         return false;
 
Index: source/Symbol/Block.cpp
===================================================================
--- source/Symbol/Block.cpp
+++ source/Symbol/Block.cpp
@@ -175,7 +175,8 @@
   if (this == block)
     return false; // This block doesn't contain itself...
 
-  // Walk the parent chain for "block" and see if any if them match this block
+  // Walk the parent chain for "block" and see if any if them match this
+  // block
   const Block *block_parent;
   for (block_parent = block->GetParent(); block_parent != nullptr;
        block_parent = block_parent->GetParent()) {
@@ -488,8 +489,8 @@
   }
   return nullptr;
 }
-// A parent of child blocks can be asked to find a sibling block given
-// one of its child blocks
+// A parent of child blocks can be asked to find a sibling block given one
+// of its child blocks
 Block *Block::GetSiblingForChild(const Block *child_block) const {
   if (!m_children.empty()) {
     collection::const_iterator pos, end = m_children.end();
Index: source/Symbol/ClangASTContext.cpp
===================================================================
--- source/Symbol/ClangASTContext.cpp
+++ source/Symbol/ClangASTContext.cpp
@@ -21,19 +21,21 @@
 // Other libraries and framework includes
 
 // Clang headers like to use NDEBUG inside of them to enable/disable debug
-// related features using "#ifndef NDEBUG" preprocessor blocks to do one thing
-// or another. This is bad because it means that if clang was built in release
-// mode, it assumes that you are building in release mode which is not always
-// the case. You can end up with functions that are defined as empty in header
-// files when NDEBUG is not defined, and this can cause link errors with the
-// clang .a files that you have since you might be missing functions in the .a
-// file. So we have to define NDEBUG when including clang headers to avoid any
-// mismatches. This is covered by rdar://problem/8691220
+// related features using "#ifndef NDEBUG" preprocessor blocks to do one
+// thing or another. This is bad because it means that if clang was built
+// in release mode, it assumes that you are building in release mode which
+// is not always the case. You can end up with functions that are defined
+// as empty in header files when NDEBUG is not defined, and this can cause
+// link errors with the clang .a files that you have since you might be
+// missing functions in the .a file. So we have to define NDEBUG when
+// including clang headers to avoid any mismatches. This is covered by
+// rdar://problem/8691220
 
 #if !defined(NDEBUG) && !defined(LLVM_NDEBUG_OFF)
 #define LLDB_DEFINED_NDEBUG_FOR_CLANG
 #define NDEBUG
-// Need to include assert.h so it is as clang would expect it to be (disabled)
+// Need to include assert.h so it is as clang would expect it to be
+// (disabled)
 #include <assert.h>
 #endif
 
@@ -60,7 +62,8 @@
 #ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG
 #undef NDEBUG
 #undef LLDB_DEFINED_NDEBUG_FOR_CLANG
-// Need to re-include assert.h so it is as _we_ would expect it to be (enabled)
+// Need to re-include assert.h so it is as _we_ would expect it to be
+// (enabled)
 #include <assert.h>
 #endif
 
@@ -118,7 +121,8 @@
          Language::LanguageIsCPlusPlus(language) ||
          Language::LanguageIsObjC(language) ||
          Language::LanguageIsPascal(language) ||
-         // Use Clang for Rust until there is a proper language plugin for it
+         // Use Clang for Rust until there is a proper language plugin for
+         // it
          language == eLanguageTypeRust ||
          language == eLanguageTypeExtRenderScript ||
          // Use Clang for D until there is a proper language plugin for it
@@ -163,8 +167,8 @@
 #undef OPERATOR_PREFIX
 #undef OPERATOR_PREFIX_LENGTH
 
-  // This is an operator, set the overloaded operator kind to invalid
-  // in case this is a conversion operator...
+  // This is an operator, set the overloaded operator kind to invalid in
+  // case this is a conversion operator...
   op_kind = clang::NUM_OVERLOADED_OPERATORS;
 
   switch (post_op_name[0]) {
@@ -375,9 +379,9 @@
 static void ParseLangArgs(LangOptions &Opts, InputKind IK, const char *triple) {
   // FIXME: Cleanup per-file based stuff.
 
-  // Set some properties which depend solely on the input kind; it would be nice
-  // to move these to the language standard, and have the driver resolve the
-  // input kind + language standard.
+  // Set some properties which depend solely on the input kind; it would
+  // be nice to move these to the language standard, and have the driver
+  // resolve the input kind + language standard.
   if (IK.getLanguage() == InputKind::Asm) {
     Opts.AsmPreprocessor = 1;
   } else if (IK.isObjectiveC()) {
@@ -440,8 +444,8 @@
 
   Opts.setValueVisibilityMode(DefaultVisibility);
 
-  // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
-  // is specified, or -std is set to a conforming mode.
+  // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs is
+  // specified, or -std is set to a conforming mode.
   Opts.Trigraphs = !Opts.GNUMode;
   Opts.CharIsSigned = ArchSpec(triple).CharIsSignedByDefault();
   Opts.OptimizeSize = 0;
@@ -452,9 +456,9 @@
   //    Opts.Optimize = Opt != 0;
   unsigned Opt = 0;
 
-  // This is the __NO_INLINE__ define, which just depends on things like the
-  // optimization level and -fno-inline, not actually whether the backend has
-  // inlining enabled.
+  // This is the __NO_INLINE__ define, which just depends on things like
+  // the optimization level and -fno-inline, not actually whether the
+  // backend has inlining enabled.
   //
   // FIXME: This is affected by other options (-fno-inline).
   Opts.NoInlineDefine = !Opt;
@@ -498,8 +502,8 @@
 
     if (arch.IsValid()) {
       ArchSpec fixed_arch = arch;
-      // LLVM wants this to be set to iOS or MacOSX; if we're working on
-      // a bare-boards type image, change the triple for llvm's benefit.
+      // LLVM wants this to be set to iOS or MacOSX; if we're working on a
+      // bare-boards type image, change the triple for llvm's benefit.
       if (fixed_arch.GetTriple().getVendor() == llvm::Triple::Apple &&
           fixed_arch.GetTriple().getOS() == llvm::Triple::UnknownOS) {
         if (fixed_arch.GetTriple().getArch() == llvm::Triple::arm ||
@@ -661,9 +665,9 @@
 
     m_ast_ap->getDiagnostics().setClient(getDiagnosticConsumer(), false);
 
-    // This can be NULL if we don't know anything about the architecture or if
-    // the
-    // target for an architecture isn't enabled in the llvm/clang that we built
+    // This can be NULL if we don't know anything about the architecture
+    // or if the target for an architecture isn't enabled in the
+    // llvm/clang that we built
     TargetInfo *target_info = getTargetInfo();
     if (target_info)
       m_ast_ap->InitBuiltinTypes(*target_info);
@@ -1177,8 +1181,8 @@
       break;
     }
   }
-  // This assert should fire for anything that we don't catch above so we know
-  // to fix any issues we run into.
+  // This assert should fire for anything that we don't catch above so we
+  // know to fix any issues we run into.
   if (type_name) {
     Host::SystemLog(Host::eSystemLogError, "error: need to add support for "
                                            "DW_TAG_base_type '%s' encoded with "
@@ -1254,9 +1258,9 @@
 }
 
 CompilerType ClangASTContext::GetTypeForDecl(TagDecl *decl) {
-  // No need to call the getASTContext() accessor (which can create the AST
-  // if it isn't created yet, because we can't have created a decl in this
-  // AST if our AST didn't already exist...
+  // No need to call the getASTContext() accessor (which can create the
+  // AST if it isn't created yet, because we can't have created a decl in
+  // this AST if our AST didn't already exist...
   ASTContext *ast = &decl->getASTContext();
   if (ast)
     return CompilerType(ast, ast->getTagDeclType(decl));
@@ -1264,9 +1268,9 @@
 }
 
 CompilerType ClangASTContext::GetTypeForDecl(ObjCInterfaceDecl *decl) {
-  // No need to call the getASTContext() accessor (which can create the AST
-  // if it isn't created yet, because we can't have created a decl in this
-  // AST if our AST didn't already exist...
+  // No need to call the getASTContext() accessor (which can create the
+  // AST if it isn't created yet, because we can't have created a decl in
+  // this AST if our AST didn't already exist...
   ASTContext *ast = &decl->getASTContext();
   if (ast)
     return CompilerType(ast, ast->getObjCInterfaceType(decl));
@@ -1293,11 +1297,11 @@
     return CreateObjCClass(name, decl_ctx, isForwardDecl, isInternal, metadata);
   }
 
-  // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
-  // we will need to update this code. I was told to currently always use
-  // the CXXRecordDecl class since we often don't know from debug information
-  // if something is struct or a class, so we default to always use the more
-  // complete definition just in case.
+  // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl
+  // and we will need to update this code. I was told to currently always
+  // use the CXXRecordDecl class since we often don't know from debug
+  // information if something is struct or a class, so we default to
+  // always use the more complete definition just in case.
 
   bool is_anonymous = (!name) || (!name[0]);
 
@@ -1404,7 +1408,8 @@
 
   for (size_t i = 0, template_param_decl_count = template_param_decls.size();
        i < template_param_decl_count; ++i) {
-    // TODO: verify which decl context we should put template_param_decls into..
+    // TODO: verify which decl context we should put template_param_decls
+    // into..
     template_param_decls[i]->setDeclContext(func_decl);
   }
 
@@ -1498,10 +1503,10 @@
   TemplateParameterList *template_param_list = CreateTemplateParameterList(
       ast, template_param_infos, template_param_decls);
 
-  // LLDB needs to create those decls only to be able to display a
-  // type that includes a template template argument. Only the name
-  // matters for this purpose, so we use dummy values for the other
-  // characterisitcs of the type.
+  // LLDB needs to create those decls only to be able to display a type
+  // that includes a template template argument. Only the name matters for
+  // this purpose, so we use dummy values for the other characterisitcs of
+  // the type.
   return TemplateTemplateParmDecl::Create(
       *ast, decl_ctx, SourceLocation(),
       /*Depth*/ 0, /*Position*/ 0,
@@ -1592,8 +1597,8 @@
 clang::AccessSpecifier
 ClangASTContext::UnifyAccessSpecifiers(clang::AccessSpecifier lhs,
                                        clang::AccessSpecifier rhs) {
-  // Make the access equal to the stricter of the field and the nested field's
-  // access
+  // Make the access equal to the stricter of the field and the nested
+  // field's access
   if (lhs == AS_none || rhs == AS_none)
     return AS_none;
   if (lhs == AS_private || rhs == AS_private)
@@ -1933,11 +1938,10 @@
     return DeclarationName(&getASTContext()->Idents.get(
         name)); // Not operator, but a regular function.
 
-  // Check the number of operator parameters. Sometimes we have
-  // seen bad DWARF that doesn't correctly describe operators and
-  // if we try to create a method and add it to the class, clang
-  // will assert and crash, so we need to make sure things are
-  // acceptable.
+  // Check the number of operator parameters. Sometimes we have seen bad
+  // DWARF that doesn't correctly describe operators and if we try to
+  // create a method and add it to the class, clang will assert and crash,
+  // so we need to make sure things are acceptable.
   clang::QualType method_qual_type(ClangUtil::GetQualType(function_clang_type));
   const clang::FunctionProtoType *function_type =
       llvm::dyn_cast<clang::FunctionProtoType>(method_qual_type.getTypePtr());
@@ -1997,8 +2001,8 @@
   // Verify that all arguments are valid and the right type
   for (unsigned i = 0; i < num_args; ++i) {
     if (args[i]) {
-      // Make sure we have a clang type in args[i] and not a type from another
-      // language whose name might match
+      // Make sure we have a clang type in args[i] and not a type from
+      // another language whose name might match
       const bool is_clang_type = ClangUtil::IsClangType(args[i]);
       lldbassert(is_clang_type);
       if (is_clang_type)
@@ -2247,8 +2251,8 @@
 
     if (lhs_decl_kind == rhs_decl_kind) {
       //------------------------------------------------------------------
-      // Now check that the decl contexts kinds are all equivalent
-      // before we have to check any names of the decl contexts...
+      // Now check that the decl contexts kinds are all equivalent before
+      // we have to check any names of the decl contexts...
       //------------------------------------------------------------------
       clang::DeclContext *lhs_decl_ctx = lhs_decl->getDeclContext();
       clang::DeclContext *rhs_decl_ctx = rhs_decl->getDeclContext();
@@ -2508,8 +2512,8 @@
         if (!allow_completion)
           return false;
 
-        // Call the field_begin() accessor to for it to use the external source
-        // to load the fields...
+        // Call the field_begin() accessor to for it to use the external
+        // source to load the fields...
         clang::ExternalASTSource *external_ast_source =
             ast->getExternalSource();
         if (external_ast_source) {
@@ -2560,9 +2564,9 @@
     if (objc_class_type) {
       clang::ObjCInterfaceDecl *class_interface_decl =
           objc_class_type->getInterface();
-      // We currently can't complete objective C types through the newly added
-      // ASTContext
-      // because it only supports TagDecl objects right now...
+      // We currently can't complete objective C types through the newly
+      // added ASTContext because it only supports TagDecl objects right
+      // now...
       if (class_interface_decl) {
         if (class_interface_decl->getDefinition())
           return true;
@@ -2882,8 +2886,8 @@
   if (type_flags.AnySet(eTypeIsArray | eTypeIsPointer)) {
     if (pointee_or_element_clang_type.IsCharType()) {
       if (type_flags.Test(eTypeIsArray)) {
-        // We know the size of the array and it could be a C string
-        // since it is an array of characters
+        // We know the size of the array and it could be a C string since
+        // it is an array of characters
         length = llvm::cast<clang::ConstantArrayType>(
                      GetCanonicalQualType(type).getTypePtr())
                      ->getSize()
@@ -2972,8 +2976,8 @@
       if (record_type) {
         const clang::RecordDecl *record_decl = record_type->getDecl();
         if (record_decl) {
-          // We are looking for a structure that contains only floating point
-          // types
+          // We are looking for a structure that contains only floating
+          // point types
           clang::RecordDecl::field_iterator field_pos,
               field_end = record_decl->field_end();
           uint32_t num_fields = 0;
@@ -3622,10 +3626,10 @@
     }
 
     if (success) {
-      // Check to make sure what we are pointing too is a possible dynamic C++
-      // type
-      // We currently accept any "void *" (in case we have a class that has been
-      // watered down to an opaque pointer) and virtual C++ classes.
+      // Check to make sure what we are pointing too is a possible dynamic
+      // C++ type We currently accept any "void *" (in case we have a
+      // class that has been watered down to an opaque pointer) and
+      // virtual C++ classes.
       const clang::Type::TypeClass pointee_type_class =
           pointee_qual_type.getCanonicalType()->getTypeClass();
       switch (pointee_type_class) {
@@ -4067,7 +4071,8 @@
   if (!type)
     return lldb::eLanguageTypeC;
 
-  // If the type is a reference, then resolve it to what it refers to first:
+  // If the type is a reference, then resolve it to what it refers to
+  // first:
   clang::QualType qual_type(GetCanonicalQualType(type).getNonReferenceType());
   if (qual_type->isAnyPointerType()) {
     if (qual_type->isObjCObjectPointerType())
@@ -4776,10 +4781,9 @@
         tdecl = et->getDecl();
     }
 
-    // Check whether this declaration is an anonymous struct, union, or enum,
-    // hidden behind a typedef. If so, we
-    // try to check whether we have a typedef tag to attach to the original
-    // record declaration
+    // Check whether this declaration is an anonymous struct, union, or
+    // enum, hidden behind a typedef. If so, we try to check whether we
+    // have a typedef tag to attach to the original record declaration
     if (tdecl && !tdecl->getIdentifier() && !tdecl->getTypedefNameForAnonDecl())
       tdecl->setTypedefNameForAnonDecl(decl);
 
@@ -5005,8 +5009,8 @@
       break;
     }
     break;
-  // All pointer types are represented as unsigned integer encodings.
-  // We may nee to add a eEncodingPointer if we ever need to know the
+  // All pointer types are represented as unsigned integer encodings. We
+  // may nee to add a eEncodingPointer if we ever need to know the
   // difference
   case clang::Type::ObjCObjectPointer:
   case clang::Type::BlockPointer:
@@ -5324,10 +5328,10 @@
           llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
       if (cxx_record_decl) {
         if (omit_empty_base_classes) {
-          // Check each base classes to see if it or any of its
-          // base classes contain any fields. This can help
-          // limit the noise in variable views by not having to
-          // show base classes that contain no members.
+          // Check each base classes to see if it or any of its base
+          // classes contain any fields. This can help limit the noise in
+          // variable views by not having to show base classes that
+          // contain no members.
           clang::CXXRecordDecl::base_class_const_iterator base_class,
               base_class_end;
           for (base_class = cxx_record_decl->bases_begin(),
@@ -5420,8 +5424,8 @@
         CompilerType(getASTContext(), pointee_type)
             .GetNumChildren(omit_empty_base_classes);
     if (num_pointee_children == 0) {
-      // We have a pointer to a pointee type that claims it has no children.
-      // We will want to look at
+      // We have a pointer to a pointee type that claims it has no
+      // children. We will want to look at
       num_children = GetNumPointeeChildren(pointee_type);
     } else
       num_children = num_pointee_children;
@@ -6168,9 +6172,10 @@
 
 // If a pointer to a pointee type (the clang_type arg) says that it has no
 // children, then we either need to trust it, or override it and return a
-// different result. For example, an "int *" has one child that is an integer,
-// but a function pointer doesn't have any children. Likewise if a Record type
-// claims it has no children, then there really is nothing to show.
+// different result. For example, an "int *" has one child that is an
+// integer, but a function pointer doesn't have any children. Likewise if
+// a Record type claims it has no children, then there really is nothing
+// to show.
 uint32_t ClangASTContext::GetNumPointeeChildren(clang::QualType type) {
   if (type.isNull())
     return 0;
@@ -6432,8 +6437,9 @@
                               process->ReadPointerFromMemory(vbtable_ptr_addr,
                                                              err);
                           if (vbtable_ptr != LLDB_INVALID_ADDRESS) {
-                            // Get the index into the virtual base table. The
-                            // index is the index in uint32_t from vbtable_ptr
+                            // Get the index into the virtual base table.
+                            // The index is the index in uint32_t from
+                            // vbtable_ptr
                             const unsigned vbtable_index =
                                 msoft_vtable_ctx->getVBTableIndex(
                                     cxx_record_decl, base_class_decl);
@@ -6497,14 +6503,15 @@
                 base_class_clang_type.GetBitSize(
                     exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
 
-            // Base classes bit sizes should be a multiple of 8 bits in size
+            // Base classes bit sizes should be a multiple of 8 bits in
+            // size
             assert(base_class_clang_type_bit_size % 8 == 0);
             child_byte_size = base_class_clang_type_bit_size / 8;
             child_is_base_class = true;
             return base_class_clang_type;
           }
-          // We don't increment the child index in the for loop since we might
-          // be skipping empty base classes
+          // We don't increment the child index in the for loop since we
+          // might be skipping empty base classes
           ++child_idx;
         }
       }
@@ -6527,8 +6534,8 @@
               exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
           const uint32_t child_bit_size = child_byte_size * 8;
 
-          // Figure out the field offset within the current struct/union/class
-          // type
+          // Figure out the field offset within the current
+          // struct/union/class type
           bit_offset = record_layout.getFieldOffset(field_idx);
           if (ClangASTContext::FieldIsBitfield(getASTContext(), *field,
                                                child_bitfield_bit_size)) {
@@ -6615,15 +6622,12 @@
                 child_byte_size = ivar_type_info.Width / 8;
 
                 // Figure out the field offset within the current
-                // struct/union/class type
-                // For ObjC objects, we can't trust the bit offset we get from
-                // the Clang AST, since
+                // struct/union/class type For ObjC objects, we can't
+                // trust the bit offset we get from the Clang AST, since
                 // that doesn't account for the space taken up by unbacked
-                // properties, or from
-                // the changing size of base classes that are newer than this
-                // class.
-                // So if we have a process around that we can ask about this
-                // object, do so.
+                // properties, or from the changing size of base classes
+                // that are newer than this class. So if we have a process
+                // around that we can ask about this object, do so.
                 child_byte_offset = LLDB_INVALID_IVAR_OFFSET;
                 Process *process = nullptr;
                 if (exe_ctx)
@@ -6639,8 +6643,8 @@
                   }
                 }
 
-                // Setting this to UINT32_MAX to make sure we don't compute it
-                // twice...
+                // Setting this to UINT32_MAX to make sure we don't
+                // compute it twice...
                 bit_offset = UINT32_MAX;
 
                 if (child_byte_offset ==
@@ -6650,12 +6654,11 @@
                   child_byte_offset = bit_offset / 8;
                 }
 
-                // Note, the ObjC Ivar Byte offset is just that, it doesn't
-                // account for the bit offset
-                // of a bitfield within its containing object.  So regardless of
-                // where we get the byte
-                // offset from, we still need to get the bit offset for
-                // bitfields from the layout.
+                // Note, the ObjC Ivar Byte offset is just that, it
+                // doesn't account for the bit offset of a bitfield within
+                // its containing object.  So regardless of where we get
+                // the byte offset from, we still need to get the bit
+                // offset for bitfields from the layout.
 
                 if (ClangASTContext::FieldIsBitfield(getASTContext(), ivar_decl,
                                                      child_bitfield_bit_size)) {
@@ -6924,9 +6927,9 @@
   return UINT32_MAX;
 }
 
-// Look for a child member (doesn't include base classes, but it does include
-// their members) in the type hierarchy. Returns an index path into "clang_type"
-// on how to reach the appropriate member.
+// Look for a child member (doesn't include base classes, but it does
+// include their members) in the type hierarchy. Returns an index path
+// into "clang_type" on how to reach the appropriate member.
 //
 //    class A
 //    {
@@ -6945,20 +6948,18 @@
 //    {
 //    };
 //
-// If we have a clang type that describes "class C", and we wanted to looked
-// "m_b" in it:
+// If we have a clang type that describes "class C", and we wanted to
+// looked "m_b" in it:
 //
-// With omit_empty_base_classes == false we would get an integer array back
-// with:
-// { 1,  1 }
-// The first index 1 is the child index for "class A" within class C
-// The second index 1 is the child index for "m_b" within class A
+// With omit_empty_base_classes == false we would get an integer array
+// back with: { 1,  1 } The first index 1 is the child index for "class A"
+// within class C The second index 1 is the child index for "m_b" within
+// class A
 //
-// With omit_empty_base_classes == true we would get an integer array back with:
-// { 0,  1 }
-// The first index 0 is the child index for "class A" within class C (since
-// class B doesn't have any members it doesn't count)
-// The second index 1 is the child index for "m_b" within class A
+// With omit_empty_base_classes == true we would get an integer array back
+// with: { 0,  1 } The first index 0 is the child index for "class A"
+// within class C (since class B doesn't have any members it doesn't
+// count) The second index 1 is the child index for "m_b" within class A
 
 size_t ClangASTContext::GetIndexOfChildMemberWithName(
     lldb::opaque_compiler_type_t type, const char *name,
@@ -7006,7 +7007,8 @@
         if (cxx_record_decl) {
           const clang::RecordDecl *parent_record_decl = cxx_record_decl;
 
-          // printf ("parent = %s\n", parent_record_decl->getNameAsCString());
+          // printf ("parent = %s\n",
+          // parent_record_decl->getNameAsCString());
 
           // const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl();
           // Didn't find things easily, lets let clang do its thang...
@@ -7093,9 +7095,9 @@
             }
 
             if (superclass_interface_decl) {
-              // The super class index is always zero for ObjC classes,
-              // so we push it onto the child indexes in case we find
-              // an ivar in our superclass...
+              // The super class index is always zero for ObjC classes, so
+              // we push it onto the child indexes in case we find an ivar
+              // in our superclass...
               child_indexes.push_back(0);
 
               CompilerType superclass_clang_type(
@@ -7103,14 +7105,13 @@
                                        superclass_interface_decl));
               if (superclass_clang_type.GetIndexOfChildMemberWithName(
                       name, omit_empty_base_classes, child_indexes)) {
-                // We did find an ivar in a superclass so just
-                // return the results!
+                // We did find an ivar in a superclass so just return the
+                // results!
                 return child_indexes.size();
               }
 
-              // We didn't find an ivar matching "name" in our
-              // superclass, pop the superclass zero index that
-              // we pushed on above.
+              // We didn't find an ivar matching "name" in our superclass,
+              // pop the superclass zero index that we pushed on above.
               child_indexes.pop_back();
             }
           }
@@ -7224,9 +7225,9 @@
   return 0;
 }
 
-// Get the index of the child of "clang_type" whose name matches. This function
-// doesn't descend into the children, but only looks one level deep and name
-// matches can include base class names.
+// Get the index of the child of "clang_type" whose name matches. This
+// function doesn't descend into the children, but only looks one level
+// deep and name matches can include base class names.
 
 uint32_t
 ClangASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
@@ -7703,8 +7704,8 @@
         clang::ICIS_NoInit);                           // HasInit
 
     if (!name) {
-      // Determine whether this field corresponds to an anonymous
-      // struct or union.
+      // Determine whether this field corresponds to an anonymous struct
+      // or union.
       if (const clang::TagType *TagT =
               field->getType()->getAs<clang::TagType>()) {
         if (clang::RecordDecl *Rec =
@@ -7983,10 +7984,10 @@
 
     if (IsOperator(name, op_kind)) {
       if (op_kind != clang::NUM_OVERLOADED_OPERATORS) {
-        // Check the number of operator parameters. Sometimes we have
-        // seen bad DWARF that doesn't correctly describe operators and
-        // if we try to create a method and add it to the class, clang
-        // will assert and crash, so we need to make sure things are
+        // Check the number of operator parameters. Sometimes we have seen
+        // bad DWARF that doesn't correctly describe operators and if we
+        // try to create a method and add it to the class, clang will
+        // assert and crash, so we need to make sure things are
         // acceptable.
         const bool is_method = true;
         if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount(
@@ -8057,12 +8058,13 @@
 
   cxx_record_decl->addDecl(cxx_method_decl);
 
-  // Sometimes the debug info will mention a constructor (default/copy/move),
-  // destructor, or assignment operator (copy/move) but there won't be any
-  // version of this in the code. So we check if the function was artificially
-  // generated and if it is trivial and this lets the compiler/backend know
-  // that it can inline the IR for these when it needs to and we can avoid a
-  // "missing function" error when running expressions.
+  // Sometimes the debug info will mention a constructor
+  // (default/copy/move), destructor, or assignment operator (copy/move)
+  // but there won't be any version of this in the code. So we check if
+  // the function was artificially generated and if it is trivial and this
+  // lets the compiler/backend know that it can inline the IR for these
+  // when it needs to and we can avoid a "missing function" error when
+  // running expressions.
 
   if (is_artificial) {
     if (cxx_ctor_decl && ((cxx_ctor_decl->isDefaultConstructor() &&
@@ -8667,8 +8669,8 @@
   clang::QualType qual_type(ClangUtil::GetQualType(type));
   if (!qual_type.isNull()) {
     // Make sure we use the same methodology as
-    // ClangASTContext::StartTagDeclarationDefinition()
-    // as to how we start/end the definition. Previously we were calling
+    // ClangASTContext::StartTagDeclarationDefinition() as to how we
+    // start/end the definition. Previously we were calling
     const clang::TagType *tag_type = qual_type->getAs<clang::TagType>();
     if (tag_type) {
       clang::TagDecl *tag_decl = tag_type->getDecl();
@@ -8708,8 +8710,8 @@
             unsigned NumNegativeBits = 0;
 
             clang::QualType promotion_qual_type;
-            // If the enum integer type is less than an integer in bit width,
-            // then we must promote it to an integer size.
+            // If the enum integer type is less than an integer in bit
+            // width, then we must promote it to an integer size.
             if (ast->getTypeSize(enum_decl->getIntegerType()) <
                 ast->getTypeSize(ast->IntTy)) {
               if (enum_decl->getIntegerType()->isSignedIntegerType())
@@ -8938,9 +8940,9 @@
       for (field = record_decl->field_begin(),
           field_end = record_decl->field_end();
            field != field_end; ++field, ++field_idx, ++child_idx) {
-        // Print the starting squiggly bracket (if this is the
-        // first member) or comma (for member 2 and beyond) for
-        // the struct/union/class member.
+        // Print the starting squiggly bracket (if this is the first
+        // member) or comma (for member 2 and beyond) for the
+        // struct/union/class member.
         if (child_idx == 0)
           s->PutChar('{');
         else
@@ -8956,8 +8958,8 @@
         clang::TypeInfo field_type_info =
             getASTContext()->getTypeInfo(field_type);
         assert(field_idx < record_layout.getFieldCount());
-        // Figure out the field offset within the current struct/union/class
-        // type
+        // Figure out the field offset within the current
+        // struct/union/class type
         field_bit_offset = record_layout.getFieldOffset(field_idx);
         field_byte_offset = field_bit_offset / 8;
         uint32_t field_bitfield_bit_size = 0;
@@ -9062,9 +9064,9 @@
       lldb::Format element_format = element_clang_type.GetFormat();
 
       for (element_idx = 0; element_idx < element_count; ++element_idx) {
-        // Print the starting squiggly bracket (if this is the
-        // first member) or comman (for member 2 and beyong) for
-        // the struct/union/class member.
+        // Print the starting squiggly bracket (if this is the first
+        // member) or comman (for member 2 and beyong) for the
+        // struct/union/class member.
         if (element_idx == 0)
           s->PutChar('{');
         else
@@ -9073,8 +9075,8 @@
         // Indent and print the index
         s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT, "", element_idx);
 
-        // Figure out the field offset within the current struct/union/class
-        // type
+        // Figure out the field offset within the current
+        // struct/union/class type
         element_offset = element_idx * element_stride;
 
         // Dump the value of the member
@@ -9282,8 +9284,8 @@
               return true;
             }
           }
-          // If we have gotten here we didn't get find the enumerator in the
-          // enum decl, so just print the integer.
+          // If we have gotten here we didn't get find the enumerator in
+          // the enum decl, so just print the integer.
           s->Printf("%" PRIi64, enum_svalue);
         } else {
           const uint64_t enum_uvalue = data.GetMaxU64Bitfield(
@@ -9296,8 +9298,8 @@
               return true;
             }
           }
-          // If we have gotten here we didn't get find the enumerator in the
-          // enum decl, so just print the integer.
+          // If we have gotten here we didn't get find the enumerator in
+          // the enum decl, so just print the integer.
           s->Printf("%" PRIu64, enum_uvalue);
         }
         return true;
@@ -9311,8 +9313,7 @@
       {
         uint32_t item_count = 1;
         // A few formats, we might need to modify our size and count for
-        // depending
-        // on how we are trying to display the value...
+        // depending on how we are trying to display the value...
         switch (format) {
         default:
         case eFormatBoolean:
@@ -9553,9 +9554,9 @@
       if (objc_class_type) {
         clang::ObjCInterfaceDecl *class_interface_decl =
             objc_class_type->getInterface();
-        // We currently can't complete objective C types through the newly added
-        // ASTContext
-        // because it only supports TagDecl objects right now...
+        // We currently can't complete objective C types through the newly
+        // added ASTContext because it only supports TagDecl objects right
+        // now...
         if (class_interface_decl)
           printf("@class %s", class_interface_decl->getName().str().c_str());
       }
@@ -9811,17 +9812,14 @@
   return found_decls;
 }
 
-// Look for child_decl_ctx's lookup scope in frame_decl_ctx and its parents,
-// and return the number of levels it took to find it, or
-// LLDB_INVALID_DECL_LEVEL
-// if not found.  If the decl was imported via a using declaration, its name
-// and/or
-// type, if set, will be used to check that the decl found in the scope is a
-// match.
+// Look for child_decl_ctx's lookup scope in frame_decl_ctx and its
+// parents, and return the number of levels it took to find it, or
+// LLDB_INVALID_DECL_LEVEL if not found.  If the decl was imported via a
+// using declaration, its name and/or type, if set, will be used to check
+// that the decl found in the scope is a match.
 //
 // The optional name is required by languages (like C++) to handle using
-// declarations
-// like:
+// declarations like:
 //
 //     void poo();
 //     namespace ns {
@@ -9834,8 +9832,8 @@
 //         // LLDB_INVALID_DECL_LEVEL for 'goo'.
 //     }
 //
-// The optional type is useful in the case that there's a specific overload
-// that we're looking for that might otherwise be shadowed, like:
+// The optional type is useful in the case that there's a specific
+// overload that we're looking for that might otherwise be shadowed, like:
 //
 //     void foo(int);
 //     namespace ns {
@@ -9848,16 +9846,13 @@
 //         // LLDB_INVALID_DECL_LEVEL for { 'foo', void(int, int) }.
 //     }
 //
-// NOTE: Because file statics are at the TranslationUnit along with globals, a
-// function at file scope will return the same level as a function at global
-// scope.
-// Ideally we'd like to treat the file scope as an additional scope just below
-// the
-// global scope.  More work needs to be done to recognise that, if the decl
-// we're
-// trying to look up is static, we should compare its source file with that of
-// the
-// current scope and return a lower number for it.
+// NOTE: Because file statics are at the TranslationUnit along with
+// globals, a function at file scope will return the same level as a
+// function at global scope. Ideally we'd like to treat the file scope as
+// an additional scope just below the global scope.  More work needs to be
+// done to recognise that, if the decl we're trying to look up is static,
+// we should compare its source file with that of the current scope and
+// return a lower number for it.
 uint32_t ClangASTContext::CountDeclLevels(clang::DeclContext *frame_decl_ctx,
                                           clang::DeclContext *child_decl_ctx,
                                           ConstString *child_name,
@@ -9885,11 +9880,9 @@
         if (searched.find(it->second) != searched.end())
           continue;
 
-        // Currently DWARF has one shared translation unit for all Decls at top
-        // level, so this
-        // would erroneously find using statements anywhere.  So don't look at
-        // the top-level
-        // translation unit.
+        // Currently DWARF has one shared translation unit for all Decls
+        // at top level, so this would erroneously find using statements
+        // anywhere.  So don't look at the top-level translation unit.
         // TODO fix this and add a testcase that depends on it.
 
         if (llvm::isa<clang::TranslationUnitDecl>(it->second))
Index: source/Symbol/ClangASTImporter.cpp
===================================================================
--- source/Symbol/ClangASTImporter.cpp
+++ source/Symbol/ClangASTImporter.cpp
@@ -353,9 +353,9 @@
     if (objc_class_type) {
       clang::ObjCInterfaceDecl *class_interface_decl =
           objc_class_type->getInterface();
-      // We currently can't complete objective C types through the newly added
-      // ASTContext
-      // because it only supports TagDecl objects right now...
+      // We currently can't complete objective C types through the newly
+      // added ASTContext because it only supports TagDecl objects right
+      // now...
       if (class_interface_decl) {
         if (ResolveDeclOrigin(class_interface_decl, NULL, NULL))
           return true;
@@ -430,9 +430,9 @@
     if (objc_class_type) {
       clang::ObjCInterfaceDecl *class_interface_decl =
           objc_class_type->getInterface();
-      // We currently can't complete objective C types through the newly added
-      // ASTContext
-      // because it only supports TagDecl objects right now...
+      // We currently can't complete objective C types through the newly
+      // added ASTContext because it only supports TagDecl objects right
+      // now...
       if (class_interface_decl) {
         if (ResolveDeclOrigin(class_interface_decl, NULL, NULL))
           return CompleteAndFetchChildren(qual_type);
@@ -896,9 +896,9 @@
     }
   }
 
-  // If we're dealing with an Objective-C class, ensure that the inheritance has
-  // been set up correctly.  The ASTImporter may not do this correctly if the
-  // class was originally sourced from symbols.
+  // If we're dealing with an Objective-C class, ensure that the
+  // inheritance has been set up correctly.  The ASTImporter may not do
+  // this correctly if the class was originally sourced from symbols.
 
   if (ObjCInterfaceDecl *to_objc_interface = dyn_cast<ObjCInterfaceDecl>(to)) {
     do {
Index: source/Symbol/ClangExternalASTSourceCallbacks.cpp
===================================================================
--- source/Symbol/ClangExternalASTSourceCallbacks.cpp
+++ source/Symbol/ClangExternalASTSourceCallbacks.cpp
@@ -14,19 +14,21 @@
 // Other libraries and framework includes
 
 // Clang headers like to use NDEBUG inside of them to enable/disable debug
-// related features using "#ifndef NDEBUG" preprocessor blocks to do one thing
-// or another. This is bad because it means that if clang was built in release
-// mode, it assumes that you are building in release mode which is not always
-// the case. You can end up with functions that are defined as empty in header
-// files when NDEBUG is not defined, and this can cause link errors with the
-// clang .a files that you have since you might be missing functions in the .a
-// file. So we have to define NDEBUG when including clang headers to avoid any
-// mismatches. This is covered by rdar://problem/8691220
+// related features using "#ifndef NDEBUG" preprocessor blocks to do one
+// thing or another. This is bad because it means that if clang was built
+// in release mode, it assumes that you are building in release mode which
+// is not always the case. You can end up with functions that are defined
+// as empty in header files when NDEBUG is not defined, and this can cause
+// link errors with the clang .a files that you have since you might be
+// missing functions in the .a file. So we have to define NDEBUG when
+// including clang headers to avoid any mismatches. This is covered by
+// rdar://problem/8691220
 
 #if !defined(NDEBUG) && !defined(LLVM_NDEBUG_OFF)
 #define LLDB_DEFINED_NDEBUG_FOR_CLANG
 #define NDEBUG
-// Need to include assert.h so it is as clang would expect it to be (disabled)
+// Need to include assert.h so it is as clang would expect it to be
+// (disabled)
 #include <assert.h>
 #endif
 
@@ -36,7 +38,8 @@
 #ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG
 #undef NDEBUG
 #undef LLDB_DEFINED_NDEBUG_FOR_CLANG
-// Need to re-include assert.h so it is as _we_ would expect it to be (enabled)
+// Need to re-include assert.h so it is as _we_ would expect it to be
+// (enabled)
 #include <assert.h>
 #endif
 
Index: source/Symbol/ClangUtil.cpp
===================================================================
--- source/Symbol/ClangUtil.cpp
+++ source/Symbol/ClangUtil.cpp
@@ -5,8 +5,8 @@
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
-// A collection of helper methods and data structures for manipulating clang
-// types and decls.
+// A collection of helper methods and data structures for manipulating
+// clang types and decls.
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/ClangUtil.h"
Index: source/Symbol/CompactUnwindInfo.cpp
===================================================================
--- source/Symbol/CompactUnwindInfo.cpp
+++ source/Symbol/CompactUnwindInfo.cpp
@@ -261,9 +261,8 @@
 
   if (m_unwindinfo_data_computed == false) {
     if (m_section_sp->IsEncrypted()) {
-      // Can't get section contents of a protected/encrypted section until we
-      // have a live
-      // process and can read them out of memory.
+      // Can't get section contents of a protected/encrypted section until
+      // we have a live process and can read them out of memory.
       if (process_sp.get() == nullptr)
         return;
       m_section_contents_if_encrypted.reset(
@@ -294,13 +293,11 @@
 
     // struct unwind_info_section_header
     // {
-    // uint32_t    version;            // UNWIND_SECTION_VERSION
-    // uint32_t    commonEncodingsArraySectionOffset;
-    // uint32_t    commonEncodingsArrayCount;
-    // uint32_t    personalityArraySectionOffset;
-    // uint32_t    personalityArrayCount;
-    // uint32_t    indexSectionOffset;
-    // uint32_t    indexCount;
+    // uint32_t    version;            // UNWIND_SECTION_VERSION uint32_t
+    // commonEncodingsArraySectionOffset; uint32_t
+    // commonEncodingsArrayCount; uint32_t
+    // personalityArraySectionOffset; uint32_t    personalityArrayCount;
+    // uint32_t    indexSectionOffset; uint32_t    indexCount;
 
     m_unwind_header.version = m_unwindinfo_data.GetU32(&offset);
     m_unwind_header.common_encodings_array_offset =
@@ -329,11 +326,10 @@
       return;
     }
 
-    // Parse the basic information from the indexes
-    // We wait to scan the second level page info until it's needed
+    // Parse the basic information from the indexes We wait to scan the
+    // second level page info until it's needed
 
-    // struct unwind_info_section_header_index_entry
-    // {
+    // struct unwind_info_section_header_index_entry {
     //     uint32_t        functionOffset;
     //     uint32_t        secondLevelPagesSectionOffset;
     //     uint32_t        lsdaIndexArraySectionOffset;
@@ -388,8 +384,7 @@
 uint32_t CompactUnwindInfo::GetLSDAForFunctionOffset(uint32_t lsda_offset,
                                                      uint32_t lsda_count,
                                                      uint32_t function_offset) {
-  // struct unwind_info_section_header_lsda_index_entry
-  // {
+  // struct unwind_info_section_header_lsda_index_entry {
   //         uint32_t        functionOffset;
   //         uint32_t        lsdaOffset;
   // };
@@ -418,9 +413,8 @@
 lldb::offset_t CompactUnwindInfo::BinarySearchRegularSecondPage(
     uint32_t entry_page_offset, uint32_t entry_count, uint32_t function_offset,
     uint32_t *entry_func_start_offset, uint32_t *entry_func_end_offset) {
-  // typedef uint32_t compact_unwind_encoding_t;
-  // struct unwind_info_regular_second_level_entry
-  // {
+  // typedef uint32_t compact_unwind_encoding_t; struct
+  // unwind_info_regular_second_level_entry {
   //     uint32_t                    functionOffset;
   //     compact_unwind_encoding_t    encoding;
 
@@ -540,8 +534,8 @@
   auto next_it = it + 1;
   if (next_it != m_indexes.end()) {
     // initialize the function offset end range to be the start of the
-    // next index offset.  If we find an entry which is at the end of
-    // the index table, this will establish the range end.
+    // next index offset.  If we find an entry which is at the end of the
+    // index table, this will establish the range end.
     unwind_info.valid_range_offset_end = next_it->function_offset;
   }
 
@@ -554,15 +548,13 @@
       &offset); // UNWIND_SECOND_LEVEL_REGULAR or UNWIND_SECOND_LEVEL_COMPRESSED
 
   if (kind == UNWIND_SECOND_LEVEL_REGULAR) {
-    // struct unwind_info_regular_second_level_page_header
-    // {
+    // struct unwind_info_regular_second_level_page_header {
     //     uint32_t    kind;    // UNWIND_SECOND_LEVEL_REGULAR
     //     uint16_t    entryPageOffset;
     //     uint16_t    entryCount;
 
-    // typedef uint32_t compact_unwind_encoding_t;
-    // struct unwind_info_regular_second_level_entry
-    // {
+    // typedef uint32_t compact_unwind_encoding_t; struct
+    // unwind_info_regular_second_level_entry {
     //     uint32_t                    functionOffset;
     //     compact_unwind_encoding_t    encoding;
 
@@ -612,8 +604,7 @@
     }
     return true;
   } else if (kind == UNWIND_SECOND_LEVEL_COMPRESSED) {
-    // struct unwind_info_compressed_second_level_page_header
-    // {
+    // struct unwind_info_compressed_second_level_page_header {
     //     uint32_t    kind;    // UNWIND_SECOND_LEVEL_COMPRESSED
     //     uint16_t    entryPageOffset;         // offset from this 2nd lvl page
     //     idx to array of entries
@@ -721,8 +712,8 @@
            // enough
 };
 
-// Convert the compact_unwind_info.h register numbering scheme
-// to eRegisterKindEHFrame (eh_frame) register numbering scheme.
+// Convert the compact_unwind_info.h register numbering scheme to
+// eRegisterKindEHFrame (eh_frame) register numbering scheme.
 uint32_t translate_to_eh_frame_regnum_x86_64(uint32_t unwind_regno) {
   switch (unwind_regno) {
   case UNWIND_X86_64_REG_RBX:
@@ -801,10 +792,9 @@
   } break;
 
   case UNWIND_X86_64_MODE_STACK_IND: {
-    // The clang in Xcode 6 is emitting incorrect compact unwind encodings for
-    // this
-    // style of unwind.  It was fixed in llvm r217020.
-    // The clang in Xcode 7 has this fixed.
+    // The clang in Xcode 6 is emitting incorrect compact unwind encodings
+    // for this style of unwind.  It was fixed in llvm r217020. The clang
+    // in Xcode 7 has this fixed.
     return false;
   } break;
 
@@ -861,17 +851,17 @@
 
     if (register_count > 0) {
 
-      // We need to include (up to) 6 registers in 10 bits.
-      // That would be 18 bits if we just used 3 bits per reg to indicate
-      // the order they're saved on the stack.
+      // We need to include (up to) 6 registers in 10 bits. That would be
+      // 18 bits if we just used 3 bits per reg to indicate the order
+      // they're saved on the stack.
       //
       // This is done with Lehmer code permutation, e.g. see
-      // http://stackoverflow.com/questions/1506078/fast-permutation-number-permutation-mapping-algorithms
+      // http://stackoverflow.com/questions/1506078/fast-permutation-
+      // number-permutation-mapping-algorithms
       int permunreg[6] = {0, 0, 0, 0, 0, 0};
 
-      // This decodes the variable-base number in the 10 bits
-      // and gives us the Lehmer code sequence which can then
-      // be decoded.
+      // This decodes the variable-base number in the 10 bits and gives us
+      // the Lehmer code sequence which can then be decoded.
 
       switch (register_count) {
       case 6:
@@ -923,8 +913,8 @@
         break;
       }
 
-      // Decode the Lehmer code for this permutation of
-      // the registers v. http://en.wikipedia.org/wiki/Lehmer_code
+      // Decode the Lehmer code for this permutation of the registers v.
+      // http://en.wikipedia.org/wiki/Lehmer_code
 
       int registers[6] = {UNWIND_X86_64_REG_NONE, UNWIND_X86_64_REG_NONE,
                           UNWIND_X86_64_REG_NONE, UNWIND_X86_64_REG_NONE,
@@ -993,8 +983,8 @@
           // enough
 };
 
-// Convert the compact_unwind_info.h register numbering scheme
-// to eRegisterKindEHFrame (eh_frame) register numbering scheme.
+// Convert the compact_unwind_info.h register numbering scheme to
+// eRegisterKindEHFrame (eh_frame) register numbering scheme.
 uint32_t translate_to_eh_frame_regnum_i386(uint32_t unwind_regno) {
   switch (unwind_regno) {
   case UNWIND_X86_REG_EBX:
@@ -1123,17 +1113,17 @@
 
     if (register_count > 0) {
 
-      // We need to include (up to) 6 registers in 10 bits.
-      // That would be 18 bits if we just used 3 bits per reg to indicate
-      // the order they're saved on the stack.
+      // We need to include (up to) 6 registers in 10 bits. That would be
+      // 18 bits if we just used 3 bits per reg to indicate the order
+      // they're saved on the stack.
       //
       // This is done with Lehmer code permutation, e.g. see
-      // http://stackoverflow.com/questions/1506078/fast-permutation-number-permutation-mapping-algorithms
+      // http://stackoverflow.com/questions/1506078/fast-permutation-
+      // number-permutation-mapping-algorithms
       int permunreg[6] = {0, 0, 0, 0, 0, 0};
 
-      // This decodes the variable-base number in the 10 bits
-      // and gives us the Lehmer code sequence which can then
-      // be decoded.
+      // This decodes the variable-base number in the 10 bits and gives us
+      // the Lehmer code sequence which can then be decoded.
 
       switch (register_count) {
       case 6:
@@ -1185,8 +1175,8 @@
         break;
       }
 
-      // Decode the Lehmer code for this permutation of
-      // the registers v. http://en.wikipedia.org/wiki/Lehmer_code
+      // Decode the Lehmer code for this permutation of the registers v.
+      // http://en.wikipedia.org/wiki/Lehmer_code
 
       int registers[6] = {UNWIND_X86_REG_NONE, UNWIND_X86_REG_NONE,
                           UNWIND_X86_REG_NONE, UNWIND_X86_REG_NONE,
@@ -1239,8 +1229,8 @@
   return false;
 }
 
-// DWARF register numbers from "DWARF for the ARM 64-bit Architecture (AArch64)"
-// doc by ARM
+// DWARF register numbers from "DWARF for the ARM 64-bit Architecture
+// (AArch64)" doc by ARM
 
 enum arm64_eh_regnum {
   x19 = 19,
@@ -1259,14 +1249,11 @@
   sp = 31,
   pc = 32,
 
-  // Compact unwind encodes d8-d15 but we don't have eh_frame / dwarf reg #'s
-  // for the 64-bit
-  // fp regs.  Normally in DWARF it's context sensitive - so it knows it is
-  // fetching a
-  // 32- or 64-bit quantity from reg v8 to indicate s0 or d0 - but the unwinder
-  // is operating
-  // at a lower level and we'd try to fetch 128 bits if we were told that v8
-  // were stored on
+  // Compact unwind encodes d8-d15 but we don't have eh_frame / dwarf reg
+  // #'s for the 64-bit fp regs.  Normally in DWARF it's context sensitive
+  // - so it knows it is fetching a 32- or 64-bit quantity from reg v8 to
+  // indicate s0 or d0 - but the unwinder is operating at a lower level
+  // and we'd try to fetch 128 bits if we were told that v8 were stored on
   // the stack...
   v8 = 72,
   v9 = 73,
@@ -1342,7 +1329,8 @@
                       UNWIND_ARM64_FRAMELESS_STACK_SIZE_MASK)) *
         16;
 
-    // Our previous Call Frame Address is the stack pointer plus the stack size
+    // Our previous Call Frame Address is the stack pointer plus the stack
+    // size
     row->GetCFAValue().SetIsRegisterPlusOffset(arm64_eh_regnum::sp, stack_size);
 
     // Our previous PC is in the LR
@@ -1426,9 +1414,9 @@
     reg_pairs_saved_count++;
   }
 
-  // If we use the v8-v15 regnums here, the unwinder will try to grab 128 bits
-  // off the stack;
-  // not sure if we have a good way to represent the 64-bitness of these saves.
+  // If we use the v8-v15 regnums here, the unwinder will try to grab 128
+  // bits off the stack; not sure if we have a good way to represent the
+  // 64-bitness of these saves.
 
   if (saved_register_bits & UNWIND_ARM64_FRAME_D8_D9_PAIR) {
     reg_pairs_saved_count++;
@@ -1577,8 +1565,8 @@
       row->SetRegisterLocationToAtCFAPlusOffset(arm_d12, cfa_offset, true);
 
       // FIXME we don't have a way to represent reg saves at an specific
-      // alignment short of
-      // coming up with some DWARF location description.
+      // alignment short of coming up with some DWARF location
+      // description.
 
       break;
     case 5:
@@ -1591,8 +1579,8 @@
       row->SetRegisterLocationToAtCFAPlusOffset(arm_d14, cfa_offset, true);
 
       // FIXME we don't have a way to represent reg saves at an specific
-      // alignment short of
-      // coming up with some DWARF location description.
+      // alignment short of coming up with some DWARF location
+      // description.
 
       break;
     case 6:
@@ -1601,8 +1589,8 @@
       // vst   {d12, d13, d14}
 
       // FIXME we don't have a way to represent reg saves at an specific
-      // alignment short of
-      // coming up with some DWARF location description.
+      // alignment short of coming up with some DWARF location
+      // description.
 
       break;
     case 7:
@@ -1611,8 +1599,8 @@
       // vst   {d12, d13, d14, d15}
 
       // FIXME we don't have a way to represent reg saves at an specific
-      // alignment short of
-      // coming up with some DWARF location description.
+      // alignment short of coming up with some DWARF location
+      // description.
 
       break;
     }
Index: source/Symbol/CompileUnit.cpp
===================================================================
--- source/Symbol/CompileUnit.cpp
+++ source/Symbol/CompileUnit.cpp
@@ -68,9 +68,9 @@
 
 //----------------------------------------------------------------------
 // Dump the current contents of this object. No functions that cause on
-// demand parsing of functions, globals, statics are called, so this
-// is a good function to call to get an idea of the current contents of
-// the CompileUnit object.
+// demand parsing of functions, globals, statics are called, so this is a
+// good function to call to get an idea of the current contents of the
+// CompileUnit object.
 //----------------------------------------------------------------------
 void CompileUnit::Dump(Stream *s, bool show_context) const {
   const char *language = Language::GetNameForLanguageType(m_language);
@@ -118,28 +118,27 @@
 }
 
 //----------------------------------------------------------------------
-// Find functions using the Mangled::Tokens token list. This
-// function currently implements an interactive approach designed to find
-// all instances of certain functions. It isn't designed to the
-// quickest way to lookup functions as it will need to iterate through
-// all functions and see if they match, though it does provide a powerful
-// and context sensitive way to search for all functions with a certain
-// name, all functions in a namespace, or all functions of a template
-// type. See Mangled::Tokens::Parse() comments for more information.
+// Find functions using the Mangled::Tokens token list. This function
+// currently implements an interactive approach designed to find all
+// instances of certain functions. It isn't designed to the quickest way
+// to lookup functions as it will need to iterate through all functions
+// and see if they match, though it does provide a powerful and context
+// sensitive way to search for all functions with a certain name, all
+// functions in a namespace, or all functions of a template type. See
+// Mangled::Tokens::Parse() comments for more information.
 //
-// The function prototype will need to change to return a list of
-// results. It was originally used to help debug the Mangled class
-// and the Mangled::Tokens::MatchesQuery() function and it currently
-// will print out a list of matching results for the functions that
-// are currently in this compile unit.
+// The function prototype will need to change to return a list of results.
+// It was originally used to help debug the Mangled class and the
+// Mangled::Tokens::MatchesQuery() function and it currently will print
+// out a list of matching results for the functions that are currently in
+// this compile unit.
 //
-// A FindFunctions method should be called prior to this that takes
-// a regular function name (const char * or ConstString as a parameter)
-// before resorting to this slower but more complete function. The
-// other FindFunctions method should be able to take advantage of any
-// accelerator tables available in the debug information (which is
-// parsed by the SymbolFile parser plug-ins and registered with each
-// Module).
+// A FindFunctions method should be called prior to this that takes a
+// regular function name (const char * or ConstString as a parameter)
+// before resorting to this slower but more complete function. The other
+// FindFunctions method should be able to take advantage of any
+// accelerator tables available in the debug information (which is parsed
+// by the SymbolFile parser plug-ins and registered with each Module).
 //----------------------------------------------------------------------
 // void
 // CompileUnit::FindFunctions(const Mangled::Tokens& tokens)
@@ -261,9 +260,10 @@
     if (file_idx == UINT32_MAX)
       return UINT32_MAX;
   } else {
-    // All the line table entries actually point to the version of the Compile
-    // Unit that is in the support files (the one at 0 was artificially added.)
-    // So prefer the one further on in the support files if it exists...
+    // All the line table entries actually point to the version of the
+    // Compile Unit that is in the support files (the one at 0 was
+    // artificially added.) So prefer the one further on in the support
+    // files if it exists...
     FileSpecList &support_files = GetSupportFiles();
     const bool full = true;
     file_idx = support_files.FindFileIndex(
@@ -321,23 +321,23 @@
       uint32_t line_idx;
 
       if (num_file_indexes == 1) {
-        // We only have a single support file that matches, so use
-        // the line table function that searches for a line entries
-        // that match a single support file index
+        // We only have a single support file that matches, so use the
+        // line table function that searches for a line entries that match
+        // a single support file index
         LineEntry line_entry;
         line_idx = line_table->FindLineEntryIndexByFileIndex(
             0, file_indexes.front(), line, exact, &line_entry);
 
-        // If "exact == true", then "found_line" will be the same
-        // as "line". If "exact == false", the "found_line" will be the
+        // If "exact == true", then "found_line" will be the same as
+        // "line". If "exact == false", the "found_line" will be the
         // closest line entry with a line number greater than "line" and
         // we will use this for our subsequent line exact matches below.
         found_line = line_entry.line;
 
         while (line_idx != UINT32_MAX) {
-          // If they only asked for the line entry, then we're done, we can just
-          // copy that over.
-          // But if they wanted more than just the line number, fill it in.
+          // If they only asked for the line entry, then we're done, we
+          // can just copy that over. But if they wanted more than just
+          // the line number, fill it in.
           if (resolve_scope == eSymbolContextLineEntry) {
             sc.line_entry = line_entry;
           } else {
@@ -352,14 +352,14 @@
         }
       } else {
         // We found multiple support files that match "file_spec" so use
-        // the line table function that searches for a line entries
-        // that match a multiple support file indexes.
+        // the line table function that searches for a line entries that
+        // match a multiple support file indexes.
         LineEntry line_entry;
         line_idx = line_table->FindLineEntryIndexByFileIndex(
             0, file_indexes, line, exact, &line_entry);
 
-        // If "exact == true", then "found_line" will be the same
-        // as "line". If "exact == false", the "found_line" will be the
+        // If "exact == true", then "found_line" will be the same as
+        // "line". If "exact == false", the "found_line" will be the
         // closest line entry with a line number greater than "line" and
         // we will use this for our subsequent line exact matches below.
         found_line = line_entry.line;
@@ -380,7 +380,8 @@
     }
   } else if (file_spec_matches_cu_file_spec && !check_inlines) {
     // only append the context if we aren't looking for inline call sites
-    // by file and line and if the file spec matches that of the compile unit
+    // by file and line and if the file spec matches that of the compile
+    // unit
     sc_list.Append(sc);
   }
   return sc_list.GetSize() - prev_size;
Index: source/Symbol/CompilerType.cpp
===================================================================
--- source/Symbol/CompilerType.cpp
+++ source/Symbol/CompilerType.cpp
@@ -637,9 +637,9 @@
       child_is_deref_of_parent, valobj, language_flags);
 }
 
-// Look for a child member (doesn't include base classes, but it does include
-// their members) in the type hierarchy. Returns an index path into "clang_type"
-// on how to reach the appropriate member.
+// Look for a child member (doesn't include base classes, but it does
+// include their members) in the type hierarchy. Returns an index path
+// into "clang_type" on how to reach the appropriate member.
 //
 //    class A
 //    {
@@ -658,20 +658,18 @@
 //    {
 //    };
 //
-// If we have a clang type that describes "class C", and we wanted to looked
-// "m_b" in it:
+// If we have a clang type that describes "class C", and we wanted to
+// looked "m_b" in it:
 //
-// With omit_empty_base_classes == false we would get an integer array back
-// with:
-// { 1,  1 }
-// The first index 1 is the child index for "class A" within class C
-// The second index 1 is the child index for "m_b" within class A
+// With omit_empty_base_classes == false we would get an integer array
+// back with: { 1,  1 } The first index 1 is the child index for "class A"
+// within class C The second index 1 is the child index for "m_b" within
+// class A
 //
-// With omit_empty_base_classes == true we would get an integer array back with:
-// { 0,  1 }
-// The first index 0 is the child index for "class A" within class C (since
-// class B doesn't have any members it doesn't count)
-// The second index 1 is the child index for "m_b" within class A
+// With omit_empty_base_classes == true we would get an integer array back
+// with: { 0,  1 } The first index 0 is the child index for "class A"
+// within class C (since class B doesn't have any members it doesn't
+// count) The second index 1 is the child index for "m_b" within class A
 
 size_t CompilerType::GetIndexOfChildMemberWithName(
     const char *name, bool omit_empty_base_classes,
@@ -728,9 +726,9 @@
   return false;
 }
 
-// Get the index of the child of "clang_type" whose name matches. This function
-// doesn't descend into the children, but only looks one level deep and name
-// matches can include base class names.
+// Get the index of the child of "clang_type" whose name matches. This
+// function doesn't descend into the children, but only looks one level
+// deep and name matches can include base class names.
 
 uint32_t
 CompilerType::GetIndexOfChildWithName(const char *name,
@@ -987,8 +985,8 @@
   if (!IsValid())
     return false;
 
-  // Can't convert a file address to anything valid without more
-  // context (which Module it came from)
+  // Can't convert a file address to anything valid without more context
+  // (which Module it came from)
   if (address_type == eAddressTypeFile)
     return false;
 
@@ -1029,8 +1027,8 @@
   if (!IsValid())
     return false;
 
-  // Can't convert a file address to anything valid without more
-  // context (which Module it came from)
+  // Can't convert a file address to anything valid without more context
+  // (which Module it came from)
   if (address_type == eAddressTypeFile)
     return false;
 
Index: source/Symbol/DWARFCallFrameInfo.cpp
===================================================================
--- source/Symbol/DWARFCallFrameInfo.cpp
+++ source/Symbol/DWARFCallFrameInfo.cpp
@@ -154,8 +154,9 @@
 bool DWARFCallFrameInfo::GetUnwindPlan(Address addr, UnwindPlan &unwind_plan) {
   FDEEntryMap::Entry fde_entry;
 
-  // Make sure that the Address we're searching for is the same object file
-  // as this DWARFCallFrameInfo, we only store File offsets in m_fde_index.
+  // Make sure that the Address we're searching for is the same object
+  // file as this DWARFCallFrameInfo, we only store File offsets in
+  // m_fde_index.
   ModuleSP module_sp = addr.GetModule();
   if (module_sp.get() == nullptr || module_sp->GetObjectFile() == nullptr ||
       module_sp->GetObjectFile() != &m_objfile)
@@ -168,8 +169,9 @@
 
 bool DWARFCallFrameInfo::GetAddressRange(Address addr, AddressRange &range) {
 
-  // Make sure that the Address we're searching for is the same object file
-  // as this DWARFCallFrameInfo, we only store File offsets in m_fde_index.
+  // Make sure that the Address we're searching for is the same object
+  // file as this DWARFCallFrameInfo, we only store File offsets in
+  // m_fde_index.
   ModuleSP module_sp = addr.GetModule();
   if (module_sp.get() == nullptr || module_sp->GetObjectFile() == nullptr ||
       module_sp->GetObjectFile() != &m_objfile)
@@ -291,8 +293,8 @@
       return nullptr;
     }
 
-    // m_cfi_data uses address size from target architecture of the process
-    // may ignore these fields?
+    // m_cfi_data uses address size from target architecture of the
+    // process may ignore these fields?
     if (m_type == DWARF && cie_sp->version >= CFI_VERSION4) {
       cie_sp->address_size = m_cfi_data.GetU8(&offset);
       cie_sp->segment_size = m_cfi_data.GetU8(&offset);
@@ -307,15 +309,15 @@
             : m_cfi_data.GetU8(&offset);
 
     if (cie_sp->augmentation[0]) {
-      // Get the length of the eh_frame augmentation data
-      // which starts with a ULEB128 length in bytes
+      // Get the length of the eh_frame augmentation data which starts
+      // with a ULEB128 length in bytes
       const size_t aug_data_len = (size_t)m_cfi_data.GetULEB128(&offset);
       const size_t aug_data_end = offset + aug_data_len;
       const size_t aug_str_len = strlen(cie_sp->augmentation);
-      // A 'z' may be present as the first character of the string.
-      // If present, the Augmentation Data field shall be present.
-      // The contents of the Augmentation Data shall be interpreted
-      // according to other characters in the Augmentation String.
+      // A 'z' may be present as the first character of the string. If
+      // present, the Augmentation Data field shall be present. The
+      // contents of the Augmentation Data shall be interpreted according
+      // to other characters in the Augmentation String.
       if (cie_sp->augmentation[0] == 'z') {
         // Extract the Augmentation Data
         size_t aug_str_idx = 0;
@@ -323,32 +325,29 @@
           char aug = cie_sp->augmentation[aug_str_idx];
           switch (aug) {
           case 'L':
-            // Indicates the presence of one argument in the
-            // Augmentation Data of the CIE, and a corresponding
-            // argument in the Augmentation Data of the FDE. The
-            // argument in the Augmentation Data of the CIE is
-            // 1-byte and represents the pointer encoding used
-            // for the argument in the Augmentation Data of the
-            // FDE, which is the address of a language-specific
-            // data area (LSDA). The size of the LSDA pointer is
+            // Indicates the presence of one argument in the Augmentation
+            // Data of the CIE, and a corresponding argument in the
+            // Augmentation Data of the FDE. The argument in the
+            // Augmentation Data of the CIE is 1-byte and represents the
+            // pointer encoding used for the argument in the Augmentation
+            // Data of the FDE, which is the address of a language-
+            // specific data area (LSDA). The size of the LSDA pointer is
             // specified by the pointer encoding used.
             cie_sp->lsda_addr_encoding = m_cfi_data.GetU8(&offset);
             break;
 
           case 'P':
-            // Indicates the presence of two arguments in the
-            // Augmentation Data of the CIE. The first argument
-            // is 1-byte and represents the pointer encoding
-            // used for the second argument, which is the
-            // address of a personality routine handler. The
-            // size of the personality routine pointer is
+            // Indicates the presence of two arguments in the Augmentation
+            // Data of the CIE. The first argument is 1-byte and
+            // represents the pointer encoding used for the second
+            // argument, which is the address of a personality routine
+            // handler. The size of the personality routine pointer is
             // specified by the pointer encoding used.
             //
-            // The address of the personality function will
-            // be stored at this location.  Pre-execution, it
-            // will be all zero's so don't read it until we're
-            // trying to do an unwind & the reloc has been
-            // resolved.
+            // The address of the personality function will be stored at
+            // this location.  Pre-execution, it will be all zero's so
+            // don't read it until we're trying to do an unwind & the
+            // reloc has been resolved.
             {
               uint8_t arg_ptr_encoding = m_cfi_data.GetU8(&offset);
               const lldb::addr_t pc_rel_addr = m_section_sp->GetFileAddress();
@@ -359,23 +358,22 @@
             break;
 
           case 'R':
-            // A 'R' may be present at any position after the
-            // first character of the string. The Augmentation
-            // Data shall include a 1 byte argument that
-            // represents the pointer encoding for the address
-            // pointers used in the FDE.
-            // Example: 0x1B == DW_EH_PE_pcrel | DW_EH_PE_sdata4
+            // A 'R' may be present at any position after the first
+            // character of the string. The Augmentation Data shall
+            // include a 1 byte argument that represents the pointer
+            // encoding for the address pointers used in the FDE. Example:
+            // 0x1B == DW_EH_PE_pcrel | DW_EH_PE_sdata4
             cie_sp->ptr_encoding = m_cfi_data.GetU8(&offset);
             break;
           }
         }
       } else if (strcmp(cie_sp->augmentation, "eh") == 0) {
-        // If the Augmentation string has the value "eh", then
-        // the EH Data field shall be present
+        // If the Augmentation string has the value "eh", then the EH Data
+        // field shall be present
       }
 
-      // Set the offset to be the end of the augmentation data just in case
-      // we didn't understand any of the data.
+      // Set the offset to be the end of the augmentation data just in
+      // case we didn't understand any of the data.
       offset = (uint32_t)aug_data_end;
     }
 
@@ -407,11 +405,10 @@
     m_cfi_data_initialized = true;
   }
 }
-// Scan through the eh_frame or debug_frame section looking for FDEs and noting
-// the start/end addresses
-// of the functions and a pointer back to the function's FDE for later
-// expansion.
-// Internalize CIEs as we come across them.
+// Scan through the eh_frame or debug_frame section looking for FDEs and
+// noting the start/end addresses of the functions and a pointer back to
+// the function's FDE for later expansion. Internalize CIEs as we come
+// across them.
 
 void DWARFCallFrameInfo::GetFDEIndex() {
   if (m_section_sp.get() == nullptr || m_section_sp->IsEncrypted())
@@ -461,17 +458,18 @@
                                              "entry offset of 0x%x found in "
                                              "cie/fde at 0x%x\n",
                       next_entry, current_entry);
-      // Don't trust anything in this eh_frame section if we find blatantly
-      // invalid data.
+      // Don't trust anything in this eh_frame section if we find
+      // blatantly invalid data.
       m_fde_index.Clear();
       m_fde_index_initialized = true;
       return;
     }
 
-    // An FDE entry contains CIE_pointer in debug_frame in same place as cie_id
-    // in eh_frame. CIE_pointer is an offset into the .debug_frame section.
-    // So, variable cie_offset should be equal to cie_id for debug_frame.
-    // FDE entries with cie_id == 0 shouldn't be ignored for it.
+    // An FDE entry contains CIE_pointer in debug_frame in same place as
+    // cie_id in eh_frame. CIE_pointer is an offset into the .debug_frame
+    // section. So, variable cie_offset should be equal to cie_id for
+    // debug_frame. FDE entries with cie_id == 0 shouldn't be ignored for
+    // it.
     if ((cie_id == 0 && m_type == EH) || cie_id == UINT32_MAX || len == 0) {
       auto cie_sp = ParseCIE(current_entry);
       if (!cie_sp) {
@@ -494,8 +492,8 @@
                       "error: Invalid cie offset of 0x%x "
                       "found in cie/fde at 0x%x\n",
                       cie_offset, current_entry);
-      // Don't trust anything in this eh_frame section if we find blatantly
-      // invalid data.
+      // Don't trust anything in this eh_frame section if we find
+      // blatantly invalid data.
       m_fde_index.Clear();
       m_fde_index_initialized = true;
       return;
@@ -556,9 +554,8 @@
   // FDE entries with zeroth cie_offset may occur for debug_frame.
   assert(!(m_type == EH && 0 == cie_offset) && cie_offset != UINT32_MAX);
 
-  // Translate the CIE_id from the eh_frame format, which
-  // is relative to the FDE offset, into a __eh_frame section
-  // offset
+  // Translate the CIE_id from the eh_frame format, which is relative to
+  // the FDE offset, into a __eh_frame section offset
   if (m_type == EH) {
     unwind_plan.SetSourceName("eh_frame CFI");
     cie_offset = current_entry + (is_64bit ? 12 : 4) - cie_offset;
@@ -566,10 +563,10 @@
   } else {
     unwind_plan.SetSourceName("DWARF CFI");
     // In theory the debug_frame info should be valid at all call sites
-    // ("asynchronous unwind info" as it is sometimes called) but in practice
-    // gcc et al all emit call frame info for the prologue and call sites, but
-    // not for the epilogue or all the other locations during the function
-    // reliably.
+    // ("asynchronous unwind info" as it is sometimes called) but in
+    // practice gcc et al all emit call frame info for the prologue and
+    // call sites, but not for the epilogue or all the other locations
+    // during the function reliably.
     unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
   }
   unwind_plan.SetSourcedFromCompiler(eLazyBoolYes);
@@ -602,8 +599,8 @@
           GetGNUEHPointer(m_cfi_data, &offset, cie->lsda_addr_encoding,
                           pc_rel_addr, text_addr, data_addr);
       if (offset - saved_offset != aug_data_len) {
-        // There is more in the augmentation region than we know how to process;
-        // don't read anything.
+        // There is more in the augmentation region than we know how to
+        // process; don't read anything.
         lsda_data_file_address = LLDB_INVALID_ADDRESS;
       }
       offset = saved_offset;
@@ -654,8 +651,8 @@
           // takes a single argument that represents a constant delta. The
           // required action is to create a new table row with a location
           // value that is computed by taking the current entry's location
-          // value and adding (delta * code_align). All other
-          // values in the new row are initially identical to the current row.
+          // value and adding (delta * code_align). All other values in
+          // the new row are initially identical to the current row.
           unwind_plan.AppendRow(row);
           UnwindPlan::Row *newrow = new UnwindPlan::Row;
           *newrow = *row.get();
@@ -666,15 +663,15 @@
 
         case DW_CFA_restore: { // 0xC0 - high 2 bits are 0x3, lower 6 bits are
                                // register
-          // takes a single argument that represents a register number. The
-          // required action is to change the rule for the indicated register
-          // to the rule assigned it by the initial_instructions in the CIE.
+          // takes a single argument that represents a register number.
+          // The required action is to change the rule for the indicated
+          // register to the rule assigned it by the initial_instructions
+          // in the CIE.
           uint32_t reg_num = extended_opcode;
-          // We only keep enough register locations around to
-          // unwind what is in our thread, and these are organized
-          // by the register index in that state, so we need to convert our
-          // eh_frame register number from the EH frame info, to a register
-          // index
+          // We only keep enough register locations around to unwind what
+          // is in our thread, and these are organized by the register
+          // index in that state, so we need to convert our eh_frame
+          // register number from the EH frame info, to a register index
 
           if (unwind_plan.IsValidRowIndex(0) &&
               unwind_plan.GetRowAtIndex(0)->GetRegisterInfo(reg_num,
@@ -687,11 +684,12 @@
         switch (extended_opcode) {
         case DW_CFA_set_loc: // 0x1 (Row Creation Instruction)
         {
-          // DW_CFA_set_loc takes a single argument that represents an address.
-          // The required action is to create a new table row using the
-          // specified address as the location. All other values in the new row
-          // are initially identical to the current row. The new location value
-          // should always be greater than the current one.
+          // DW_CFA_set_loc takes a single argument that represents an
+          // address. The required action is to create a new table row
+          // using the specified address as the location. All other values
+          // in the new row are initially identical to the current row.
+          // The new location value should always be greater than the
+          // current one.
           unwind_plan.AppendRow(row);
           UnwindPlan::Row *newrow = new UnwindPlan::Row;
           *newrow = *row.get();
@@ -703,9 +701,9 @@
 
         case DW_CFA_advance_loc1: // 0x2 (Row Creation Instruction)
         {
-          // takes a single uword argument that represents a constant delta.
-          // This instruction is identical to DW_CFA_advance_loc except for the
-          // encoding and size of the delta argument.
+          // takes a single uword argument that represents a constant
+          // delta. This instruction is identical to DW_CFA_advance_loc
+          // except for the encoding and size of the delta argument.
           unwind_plan.AppendRow(row);
           UnwindPlan::Row *newrow = new UnwindPlan::Row;
           *newrow = *row.get();
@@ -716,9 +714,9 @@
 
         case DW_CFA_advance_loc2: // 0x3 (Row Creation Instruction)
         {
-          // takes a single uword argument that represents a constant delta.
-          // This instruction is identical to DW_CFA_advance_loc except for the
-          // encoding and size of the delta argument.
+          // takes a single uword argument that represents a constant
+          // delta. This instruction is identical to DW_CFA_advance_loc
+          // except for the encoding and size of the delta argument.
           unwind_plan.AppendRow(row);
           UnwindPlan::Row *newrow = new UnwindPlan::Row;
           *newrow = *row.get();
@@ -729,9 +727,9 @@
 
         case DW_CFA_advance_loc4: // 0x4 (Row Creation Instruction)
         {
-          // takes a single uword argument that represents a constant delta.
-          // This instruction is identical to DW_CFA_advance_loc except for the
-          // encoding and size of the delta argument.
+          // takes a single uword argument that represents a constant
+          // delta. This instruction is identical to DW_CFA_advance_loc
+          // except for the encoding and size of the delta argument.
           unwind_plan.AppendRow(row);
           UnwindPlan::Row *newrow = new UnwindPlan::Row;
           *newrow = *row.get();
@@ -742,9 +740,10 @@
 
         case DW_CFA_restore_extended: // 0x6
         {
-          // takes a single unsigned LEB128 argument that represents a register
-          // number. This instruction is identical to DW_CFA_restore except for
-          // the encoding and size of the register argument.
+          // takes a single unsigned LEB128 argument that represents a
+          // register number. This instruction is identical to
+          // DW_CFA_restore except for the encoding and size of the
+          // register argument.
           uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
           if (unwind_plan.IsValidRowIndex(0) &&
               unwind_plan.GetRowAtIndex(0)->GetRegisterInfo(reg_num,
@@ -755,13 +754,13 @@
 
         case DW_CFA_remember_state: // 0xA
         {
-          // These instructions define a stack of information. Encountering the
-          // DW_CFA_remember_state instruction means to save the rules for every
-          // register on the current row on the stack. Encountering the
-          // DW_CFA_restore_state instruction means to pop the set of rules off
-          // the stack and place them in the current row. (This operation is
-          // useful for compilers that move epilogue code into the body of a
-          // function.)
+          // These instructions define a stack of information.
+          // Encountering the DW_CFA_remember_state instruction means to
+          // save the rules for every register on the current row on the
+          // stack. Encountering the DW_CFA_restore_state instruction
+          // means to pop the set of rules off the stack and place them in
+          // the current row. (This operation is useful for compilers that
+          // move epilogue code into the body of a function.)
           stack.push_back(row);
           UnwindPlan::Row *newrow = new UnwindPlan::Row;
           *newrow = *row.get();
@@ -771,13 +770,13 @@
 
         case DW_CFA_restore_state: // 0xB
         {
-          // These instructions define a stack of information. Encountering the
-          // DW_CFA_remember_state instruction means to save the rules for every
-          // register on the current row on the stack. Encountering the
-          // DW_CFA_restore_state instruction means to pop the set of rules off
-          // the stack and place them in the current row. (This operation is
-          // useful for compilers that move epilogue code into the body of a
-          // function.)
+          // These instructions define a stack of information.
+          // Encountering the DW_CFA_remember_state instruction means to
+          // save the rules for every register on the current row on the
+          // stack. Encountering the DW_CFA_restore_state instruction
+          // means to pop the set of rules off the stack and place them in
+          // the current row. (This operation is useful for compilers that
+          // move epilogue code into the body of a function.)
           if (stack.empty()) {
             if (log)
               log->Printf("DWARFCallFrameInfo::%s(dwarf_offset: %" PRIx32
@@ -798,10 +797,9 @@
         case DW_CFA_GNU_args_size: // 0x2e
         {
           // The DW_CFA_GNU_args_size instruction takes an unsigned LEB128
-          // operand
-          // representing an argument size. This instruction specifies the total
-          // of
-          // the size of the arguments which have been pushed onto the stack.
+          // operand representing an argument size. This instruction
+          // specifies the total of the size of the arguments which have
+          // been pushed onto the stack.
 
           // TODO: Figure out how we should handle this.
           m_cfi_data.GetULEB128(&offset);
@@ -835,8 +833,8 @@
       // takes two arguments: an unsigned LEB128 constant representing a
       // factored offset and a register number. The required action is to
       // change the rule for the register indicated by the register number
-      // to be an offset(N) rule with a value of
-      // (N = factored offset * data_align).
+      // to be an offset(N) rule with a value of (N = factored offset *
+      // data_align).
       uint8_t reg_num = extended_opcode;
       int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset) * data_align;
       reg_location.SetAtCFAPlusOffset(op_offset);
@@ -851,9 +849,10 @@
 
     case DW_CFA_offset_extended: // 0x5
     {
-      // takes two unsigned LEB128 arguments representing a register number
-      // and a factored offset. This instruction is identical to DW_CFA_offset
-      // except for the encoding and size of the register argument.
+      // takes two unsigned LEB128 arguments representing a register
+      // number and a factored offset. This instruction is identical to
+      // DW_CFA_offset except for the encoding and size of the register
+      // argument.
       uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
       int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset) * data_align;
       UnwindPlan::Row::RegisterLocation reg_location;
@@ -864,9 +863,9 @@
 
     case DW_CFA_undefined: // 0x7
     {
-      // takes a single unsigned LEB128 argument that represents a register
-      // number. The required action is to set the rule for the specified
-      // register to undefined.
+      // takes a single unsigned LEB128 argument that represents a
+      // register number. The required action is to set the rule for the
+      // specified register to undefined.
       uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
       UnwindPlan::Row::RegisterLocation reg_location;
       reg_location.SetUndefined();
@@ -876,9 +875,9 @@
 
     case DW_CFA_same_value: // 0x8
     {
-      // takes a single unsigned LEB128 argument that represents a register
-      // number. The required action is to set the rule for the specified
-      // register to same value.
+      // takes a single unsigned LEB128 argument that represents a
+      // register number. The required action is to set the rule for the
+      // specified register to same value.
       uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
       UnwindPlan::Row::RegisterLocation reg_location;
       reg_location.SetSame();
@@ -888,9 +887,9 @@
 
     case DW_CFA_register: // 0x9
     {
-      // takes two unsigned LEB128 arguments representing register numbers.
-      // The required action is to set the rule for the first register to be
-      // the second register.
+      // takes two unsigned LEB128 arguments representing register
+      // numbers. The required action is to set the rule for the first
+      // register to be the second register.
       uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
       uint32_t other_reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
       UnwindPlan::Row::RegisterLocation reg_location;
@@ -901,10 +900,9 @@
 
     case DW_CFA_def_cfa: // 0xC    (CFA Definition Instruction)
     {
-      // Takes two unsigned LEB128 operands representing a register
-      // number and a (non-factored) offset. The required action
-      // is to define the current CFA rule to use the provided
-      // register and offset.
+      // Takes two unsigned LEB128 operands representing a register number
+      // and a (non-factored) offset. The required action is to define the
+      // current CFA rule to use the provided register and offset.
       uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
       int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset);
       row.GetCFAValue().SetIsRegisterPlusOffset(reg_num, op_offset);
@@ -924,10 +922,10 @@
 
     case DW_CFA_def_cfa_offset: // 0xE    (CFA Definition Instruction)
     {
-      // Takes a single unsigned LEB128 operand representing a
-      // (non-factored) offset. The required action is to define
-      // the current CFA rule to use the provided offset (but
-      // to keep the old register).
+      // Takes a single unsigned LEB128 operand representing a (non-
+      // factored) offset. The required action is to define the current
+      // CFA rule to use the provided offset (but to keep the old
+      // register).
       int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset);
       row.GetCFAValue().SetIsRegisterPlusOffset(
           row.GetCFAValue().GetRegisterNumber(), op_offset);
@@ -945,14 +943,14 @@
 
     case DW_CFA_expression: // 0x10
     {
-      // Takes two operands: an unsigned LEB128 value representing
-      // a register number, and a DW_FORM_block value representing a DWARF
+      // Takes two operands: an unsigned LEB128 value representing a
+      // register number, and a DW_FORM_block value representing a DWARF
       // expression. The required action is to change the rule for the
       // register indicated by the register number to be an expression(E)
       // rule where E is the DWARF expression. That is, the DWARF
-      // expression computes the address. The value of the CFA is
-      // pushed on the DWARF evaluation stack prior to execution of
-      // the DWARF expression.
+      // expression computes the address. The value of the CFA is pushed
+      // on the DWARF evaluation stack prior to execution of the DWARF
+      // expression.
       uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
       uint32_t block_len = (uint32_t)m_cfi_data.GetULEB128(&offset);
       const uint8_t *block_data =
@@ -967,8 +965,8 @@
     {
       // takes two operands: an unsigned LEB128 value representing a
       // register number and a signed LEB128 factored offset. This
-      // instruction is identical to DW_CFA_offset_extended except
-      // that the second operand is signed and factored.
+      // instruction is identical to DW_CFA_offset_extended except that
+      // the second operand is signed and factored.
       uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
       int32_t op_offset = (int32_t)m_cfi_data.GetSLEB128(&offset) * data_align;
       UnwindPlan::Row::RegisterLocation reg_location;
@@ -979,10 +977,10 @@
 
     case DW_CFA_def_cfa_sf: // 0x12   (CFA Definition Instruction)
     {
-      // Takes two operands: an unsigned LEB128 value representing
-      // a register number and a signed LEB128 factored offset.
-      // This instruction is identical to DW_CFA_def_cfa except
-      // that the second operand is signed and factored.
+      // Takes two operands: an unsigned LEB128 value representing a
+      // register number and a signed LEB128 factored offset. This
+      // instruction is identical to DW_CFA_def_cfa except that the second
+      // operand is signed and factored.
       uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
       int32_t op_offset = (int32_t)m_cfi_data.GetSLEB128(&offset) * data_align;
       row.GetCFAValue().SetIsRegisterPlusOffset(reg_num, op_offset);
@@ -991,9 +989,9 @@
 
     case DW_CFA_def_cfa_offset_sf: // 0x13   (CFA Definition Instruction)
     {
-      // takes a signed LEB128 operand representing a factored
-      // offset. This instruction is identical to  DW_CFA_def_cfa_offset
-      // except that the operand is signed and factored.
+      // takes a signed LEB128 operand representing a factored offset.
+      // This instruction is identical to  DW_CFA_def_cfa_offset except
+      // that the operand is signed and factored.
       int32_t op_offset = (int32_t)m_cfi_data.GetSLEB128(&offset) * data_align;
       uint32_t cfa_regnum = row.GetCFAValue().GetRegisterNumber();
       row.GetCFAValue().SetIsRegisterPlusOffset(cfa_regnum, op_offset);
@@ -1002,13 +1000,14 @@
 
     case DW_CFA_val_expression: // 0x16
     {
-      // takes two operands: an unsigned LEB128 value representing a register
-      // number, and a DW_FORM_block value representing a DWARF expression.
-      // The required action is to change the rule for the register indicated
-      // by the register number to be a val_expression(E) rule where E is the
-      // DWARF expression. That is, the DWARF expression computes the value of
-      // the given register. The value of the CFA is pushed on the DWARF
-      // evaluation stack prior to execution of the DWARF expression.
+      // takes two operands: an unsigned LEB128 value representing a
+      // register number, and a DW_FORM_block value representing a DWARF
+      // expression. The required action is to change the rule for the
+      // register indicated by the register number to be a
+      // val_expression(E) rule where E is the DWARF expression. That is,
+      // the DWARF expression computes the value of the given register.
+      // The value of the CFA is pushed on the DWARF evaluation stack
+      // prior to execution of the DWARF expression.
       uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
       uint32_t block_len = (uint32_t)m_cfi_data.GetULEB128(&offset);
       const uint8_t *block_data =
Index: source/Symbol/FuncUnwinders.cpp
===================================================================
--- source/Symbol/FuncUnwinders.cpp
+++ source/Symbol/FuncUnwinders.cpp
@@ -174,10 +174,9 @@
       m_tried_unwind_plan_eh_frame_augmented)
     return m_unwind_plan_eh_frame_augmented_sp;
 
-  // Only supported on x86 architectures where we get eh_frame from the compiler
-  // that describes
-  // the prologue instructions perfectly, and sometimes the epilogue
-  // instructions too.
+  // Only supported on x86 architectures where we get eh_frame from the
+  // compiler that describes the prologue instructions perfectly, and
+  // sometimes the epilogue instructions too.
   if (target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_32_i386 &&
       target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64 &&
       target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64h) {
@@ -193,9 +192,9 @@
 
   m_unwind_plan_eh_frame_augmented_sp.reset(new UnwindPlan(*eh_frame_plan));
 
-  // Augment the eh_frame instructions with epilogue descriptions if necessary
-  // so the
-  // UnwindPlan can be used at any instruction in the function.
+  // Augment the eh_frame instructions with epilogue descriptions if
+  // necessary so the UnwindPlan can be used at any instruction in the
+  // function.
 
   UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
   if (assembly_profiler_sp) {
@@ -218,8 +217,8 @@
     return m_unwind_plan_debug_frame_augmented_sp;
 
   // Only supported on x86 architectures where we get debug_frame from the
-  // compiler that describes the prologue instructions perfectly, and sometimes
-  // the epilogue instructions too.
+  // compiler that describes the prologue instructions perfectly, and
+  // sometimes the epilogue instructions too.
   if (target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_32_i386 &&
       target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64 &&
       target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64h) {
@@ -238,7 +237,8 @@
       new UnwindPlan(*debug_frame_plan));
 
   // Augment the debug_frame instructions with epilogue descriptions if
-  // necessary so the UnwindPlan can be used at any instruction in the function.
+  // necessary so the UnwindPlan can be used at any instruction in the
+  // function.
 
   UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
   if (assembly_profiler_sp) {
@@ -273,10 +273,9 @@
   return m_unwind_plan_assembly_sp;
 }
 
-// This method compares the pc unwind rule in the first row of two UnwindPlans.
-// If they have the same way of getting the pc value (e.g. "CFA - 8" + "CFA is
-// sp"),
-// then it will return LazyBoolTrue.
+// This method compares the pc unwind rule in the first row of two
+// UnwindPlans. If they have the same way of getting the pc value (e.g.
+// "CFA - 8" + "CFA is sp"), then it will return LazyBoolTrue.
 LazyBool FuncUnwinders::CompareUnwindPlansForIdenticalInitialPCLocation(
     Thread &thread, const UnwindPlanSP &a, const UnwindPlanSP &b) {
   LazyBool plans_are_identical = eLazyBoolCalculate;
@@ -320,23 +319,24 @@
   UnwindPlanSP assembly_sp =
       GetAssemblyUnwindPlan(target, thread, current_offset);
 
-  // This point of this code is to detect when a function is using a
-  // non-standard ABI, and the eh_frame correctly describes that alternate ABI.
-  // This is addressing a specific situation on x86_64 linux systems where one
-  // function in a library pushes a value on the stack and jumps to another
-  // function.  So using an assembly instruction based unwind will not work when
-  // you're in the second function - the stack has been modified in a non-ABI
-  // way.  But we have eh_frame that correctly describes how to unwind from this
-  // location.  So we're looking to see if the initial pc register save location
-  // from the eh_frame is different from the assembly unwind, the arch default
-  // unwind, and the arch default at initial function entry.
+  // This point of this code is to detect when a function is using a non-
+  // standard ABI, and the eh_frame correctly describes that alternate
+  // ABI. This is addressing a specific situation on x86_64 linux systems
+  // where one function in a library pushes a value on the stack and jumps
+  // to another function.  So using an assembly instruction based unwind
+  // will not work when you're in the second function - the stack has been
+  // modified in a non-ABI way.  But we have eh_frame that correctly
+  // describes how to unwind from this location.  So we're looking to see
+  // if the initial pc register save location from the eh_frame is
+  // different from the assembly unwind, the arch default unwind, and the
+  // arch default at initial function entry.
   //
-  // We may have eh_frame that describes the entire function -- or we may have
-  // eh_frame that only describes the unwind after the prologue has executed --
-  // so we need to check both the arch default (once the prologue has executed)
-  // and the arch default at initial function entry.  And we may be running on a
-  // target where we have only some of the assembly/arch default unwind plans
-  // available.
+  // We may have eh_frame that describes the entire function -- or we may
+  // have eh_frame that only describes the unwind after the prologue has
+  // executed -- so we need to check both the arch default (once the
+  // prologue has executed) and the arch default at initial function
+  // entry.  And we may be running on a target where we have only some of
+  // the assembly/arch default unwind plans available.
 
   if (CompareUnwindPlansForIdenticalInitialPCLocation(
           thread, eh_frame_sp, arch_default_at_entry_sp) == eLazyBoolNo &&
Index: source/Symbol/Function.cpp
===================================================================
--- source/Symbol/Function.cpp
+++ source/Symbol/Function.cpp
@@ -24,8 +24,8 @@
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
-// Basic function information is contained in the FunctionInfo class.
-// It is designed to contain the name, linkage name, and declaration
+// Basic function information is contained in the FunctionInfo class. It
+// is designed to contain the name, linkage name, and declaration
 // location.
 //----------------------------------------------------------------------
 FunctionInfo::FunctionInfo(const char *name, const Declaration *decl_ptr)
@@ -187,9 +187,8 @@
   line_no = 0;
   source_file.Clear();
 
-  // The -1 is kind of cheesy, but I want to get the last line entry for the
-  // given function, not the
-  // first entry of the next.
+  // The -1 is kind of cheesy, but I want to get the last line entry for
+  // the given function, not the first entry of the next.
   Address scratch_addr(GetAddressRange().GetBaseAddress());
   scratch_addr.SetOffset(scratch_addr.GetOffset() +
                          GetAddressRange().GetByteSize() - 1);
@@ -331,9 +330,8 @@
 bool Function::GetIsOptimized() {
   bool result = false;
 
-  // Currently optimization is only indicted by the
-  // vendor extension DW_AT_APPLE_optimized which
-  // is set on a compile unit level.
+  // Currently optimization is only indicted by the vendor extension
+  // DW_AT_APPLE_optimized which is set on a compile unit level.
   if (m_comp_unit) {
     result = m_comp_unit->GetIsOptimized();
   }
@@ -415,7 +413,8 @@
       if (line_table->FindLineEntryByAddress(GetAddressRange().GetBaseAddress(),
                                              first_line_entry,
                                              &first_line_entry_idx)) {
-        // Make sure the first line entry isn't already the end of the prologue
+        // Make sure the first line entry isn't already the end of the
+        // prologue
         addr_t prologue_end_file_addr = LLDB_INVALID_ADDRESS;
         addr_t line_zero_end_file_addr = LLDB_INVALID_ADDRESS;
 
@@ -444,8 +443,8 @@
         // If we didn't find the end of the prologue in the line tables,
         // then just use the end address of the first line table entry
         if (prologue_end_file_addr == LLDB_INVALID_ADDRESS) {
-          // Check the first few instructions and look for one that has
-          // a line number that's different than the first entry.
+          // Check the first few instructions and look for one that has a
+          // line number that's different than the first entry.
           uint32_t last_line_entry_idx = first_line_entry_idx + 6;
           for (uint32_t idx = first_line_entry_idx + 1;
                idx < last_line_entry_idx; ++idx) {
Index: source/Symbol/GoASTContext.cpp
===================================================================
--- source/Symbol/GoASTContext.cpp
+++ source/Symbol/GoASTContext.cpp
@@ -667,8 +667,7 @@
 }
 
 // Returns -1 if this isn't a function of if the function doesn't have a
-// prototype
-// Returns a value >= 0 if there is a prototype.
+// prototype Returns a value >= 0 if there is a prototype.
 int GoASTContext::GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) {
   return GetNumberOfFunctionArguments(type);
 }
@@ -725,7 +724,8 @@
   return CompilerType(this, pointer);
 }
 
-// If the current object represents a typedef type, get the underlying type
+// If the current object represents a typedef type, get the underlying
+// type
 CompilerType GoASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type) {
   if (IsTypedefType(type))
     return static_cast<GoType *>(type)->GetElementType();
@@ -1032,12 +1032,12 @@
   return UINT_MAX;
 }
 
-// Lookup a child member given a name. This function will match member names
-// only and will descend into "clang_type" children in search for the first
-// member in this class, or any base class that matches "name".
+// Lookup a child member given a name. This function will match member
+// names only and will descend into "clang_type" children in search for
+// the first member in this class, or any base class that matches "name".
 // TODO: Return all matches for a given name by returning a
-// vector<vector<uint32_t>>
-// so we catch all names that match a given child name, not just the first.
+// vector<vector<uint32_t>> so we catch all names that match a given child
+// name, not just the first.
 size_t GoASTContext::GetIndexOfChildMemberWithName(
     lldb::opaque_compiler_type_t type, const char *name,
     bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) {
@@ -1080,9 +1080,9 @@
       uint32_t field_idx = 0;
       for (auto *field = st->GetField(field_idx); field != nullptr;
            field_idx++) {
-        // Print the starting squiggly bracket (if this is the
-        // first member) or comma (for member 2 and beyond) for
-        // the struct/union/class member.
+        // Print the starting squiggly bracket (if this is the first
+        // member) or comma (for member 2 and beyond) for the
+        // struct/union/class member.
         if (field_idx == 0)
           s->PutChar('{');
         else
@@ -1137,9 +1137,9 @@
 
     uint64_t element_idx;
     for (element_idx = 0; element_idx < a->GetLength(); ++element_idx) {
-      // Print the starting squiggly bracket (if this is the
-      // first member) or comman (for member 2 and beyong) for
-      // the struct/union/class member.
+      // Print the starting squiggly bracket (if this is the first member)
+      // or comman (for member 2 and beyong) for the struct/union/class
+      // member.
       if (element_idx == 0)
         s->PutChar('{');
       else
@@ -1149,7 +1149,8 @@
       s->Printf("\n%*s[%" PRIu64 "] ", depth + DEPTH_INCREMENT, "",
                 element_idx);
 
-      // Figure out the field offset within the current struct/union/class type
+      // Figure out the field offset within the current struct/union/class
+      // type
       uint64_t element_offset = element_idx * element_byte_size;
 
       // Dump the value of the member
@@ -1212,8 +1213,8 @@
     }
 
     uint32_t item_count = 1;
-    // A few formats, we might need to modify our size and count for depending
-    // on how we are trying to display the value...
+    // A few formats, we might need to modify our size and count for
+    // depending on how we are trying to display the value...
     switch (format) {
     default:
     case eFormatBoolean:
Index: source/Symbol/JavaASTContext.cpp
===================================================================
--- source/Symbol/JavaASTContext.cpp
+++ source/Symbol/JavaASTContext.cpp
@@ -219,8 +219,8 @@
   }
 
   void AddBaseClass(const CompilerType &type, uint32_t offset) {
-    // TODO: Check if type is an interface and add it to the interface list in
-    // that case
+    // TODO: Check if type is an interface and add it to the interface
+    // list in that case
     m_base_class = type;
     m_base_class_offset = offset;
   }
Index: source/Symbol/LineEntry.cpp
===================================================================
--- source/Symbol/LineEntry.cpp
+++ source/Symbol/LineEntry.cpp
@@ -192,8 +192,8 @@
 }
 
 AddressRange LineEntry::GetSameLineContiguousAddressRange() const {
-  // Add each LineEntry's range to complete_line_range until we find
-  // a different file / line number.
+  // Add each LineEntry's range to complete_line_range until we find a
+  // different file / line number.
   AddressRange complete_line_range = range;
 
   while (true) {
@@ -206,9 +206,8 @@
     if (next_line_sc.line_entry.IsValid() &&
         next_line_sc.line_entry.range.GetByteSize() > 0 &&
         original_file == next_line_sc.line_entry.original_file) {
-      // Include any line 0 entries - they indicate that this is
-      // compiler-generated code
-      // that does not correspond to user source code.
+      // Include any line 0 entries - they indicate that this is compiler-
+      // generated code that does not correspond to user source code.
       if (next_line_sc.line_entry.line == 0) {
         complete_line_range.SetByteSize(
             complete_line_range.GetByteSize() +
@@ -217,10 +216,9 @@
       }
 
       if (line == next_line_sc.line_entry.line) {
-        // next_line_sc is the same file & line as this LineEntry, so extend our
-        // AddressRange by its size and continue to see if there are more
-        // LineEntries
-        // that we can combine.
+        // next_line_sc is the same file & line as this LineEntry, so
+        // extend our AddressRange by its size and continue to see if
+        // there are more LineEntries that we can combine.
         complete_line_range.SetByteSize(
             complete_line_range.GetByteSize() +
             next_line_sc.line_entry.range.GetByteSize());
Index: source/Symbol/LineTable.cpp
===================================================================
--- source/Symbol/LineTable.cpp
+++ source/Symbol/LineTable.cpp
@@ -72,31 +72,26 @@
               is_start_of_basic_block, is_prologue_end, is_epilogue_begin,
               is_terminal_entry);
   entry_collection &entries = seq->m_entries;
-  // Replace the last entry if the address is the same, otherwise append it. If
-  // we have multiple
-  // line entries at the same address, this indicates illegal DWARF so this
-  // "fixes" the line table
-  // to be correct. If not fixed this can cause a line entry's address that when
-  // resolved back to
-  // a symbol context, could resolve to a different line entry. We really want a
-  // 1 to 1 mapping
-  // here to avoid these kinds of inconsistencies. We will need tor revisit this
-  // if the DWARF line
-  // tables are updated to allow multiple entries at the same address legally.
+  // Replace the last entry if the address is the same, otherwise append
+  // it. If we have multiple line entries at the same address,
+  // this indicates illegal DWARF so this "fixes" the line table to be
+  // correct. If not fixed this can cause a line entry's address that when
+  // resolved back to a symbol context, could resolve to a different line
+  // entry. We really want a 1 to 1 mapping here to avoid these kinds of
+  // inconsistencies. We will need tor revisit this if the DWARF line
+  // tables are updated to allow multiple entries at the same address
+  // legally.
   if (!entries.empty() && entries.back().file_addr == file_addr) {
-    // GCC don't use the is_prologue_end flag to mark the first instruction
-    // after the prologue.
-    // Instead of it it is issuing a line table entry for the first instruction
-    // of the prologue
-    // and one for the first instruction after the prologue. If the size of the
-    // prologue is 0
-    // instruction then the 2 line entry will have the same file address.
-    // Removing it will remove
-    // our ability to properly detect the location of the end of prologe so we
-    // set the prologue_end
-    // flag to preserve this information (setting the prologue_end flag for an
-    // entry what is after
-    // the prologue end don't have any effect)
+    // GCC don't use the is_prologue_end flag to mark the first
+    // instruction after the prologue. Instead of it it is issuing a line
+    // table entry for the first instruction of the prologue and one for
+    // the first instruction after the prologue. If the size of the
+    // prologue is 0 instruction then the 2 line entry will have the same
+    // file address. Removing it will remove our ability to properly
+    // detect the location of the end of prologe so we set the
+    // prologue_end flag to preserve this information (setting the
+    // prologue_end flag for an entry what is after the prologue end don't
+    // have any effect)
     entry.is_prologue_end = entry.file_idx == entries.back().file_idx;
     entries.back() = entry;
   } else
@@ -110,8 +105,8 @@
     return;
   Entry &entry = seq->m_entries.front();
 
-  // If the first entry address in this sequence is greater than or equal to
-  // the address of the last item in our entry collection, just append.
+  // If the first entry address in this sequence is greater than or equal
+  // to the address of the last item in our entry collection, just append.
   if (m_entries.empty() ||
       !Entry::EntryAddressLessThan(entry, m_entries.back())) {
     m_entries.insert(m_entries.end(), seq->m_entries.begin(),
@@ -201,13 +196,13 @@
             --pos;
           else if (pos->file_addr == search_entry.file_addr) {
             // If this is a termination entry, it shouldn't match since
-            // entries with the "is_terminal_entry" member set to true
-            // are termination entries that define the range for the
-            // previous entry.
+            // entries with the "is_terminal_entry" member set to true are
+            // termination entries that define the range for the previous
+            // entry.
             if (pos->is_terminal_entry) {
-              // The matching entry is a terminal entry, so we skip
-              // ahead to the next entry to see if there is another
-              // entry following this one whose section/offset matches.
+              // The matching entry is a terminal entry, so we skip ahead
+              // to the next entry to see if there is another entry
+              // following this one whose section/offset matches.
               ++pos;
               if (pos != end_pos) {
                 if (pos->file_addr != search_entry.file_addr)
@@ -232,16 +227,15 @@
         }
         else
         {
-          // There might be code in the containing objfile before the first line
-          // table entry.  Make sure that does not get considered part of the first
-          // line table entry.
+          // There might be code in the containing objfile before the
+          // first line table entry.  Make sure that does not get
+          // considered part of the first line table entry.
           if (pos->file_addr > so_addr.GetFileAddress())
             return false;
         }
 
         // Make sure we have a valid match and that the match isn't a
-        // terminating
-        // entry for a previous line...
+        // terminating entry for a previous line...
         if (pos != end_pos && pos->is_terminal_entry == false) {
           uint32_t match_idx = std::distance(begin_pos, pos);
           success = ConvertEntryAtIndexToLineEntry(match_idx, line_entry);
@@ -295,20 +289,18 @@
   size_t best_match = UINT32_MAX;
 
   for (size_t idx = start_idx; idx < count; ++idx) {
-    // Skip line table rows that terminate the previous row (is_terminal_entry
-    // is non-zero)
+    // Skip line table rows that terminate the previous row
+    // (is_terminal_entry is non-zero)
     if (m_entries[idx].is_terminal_entry)
       continue;
 
     if (find(begin_pos, end_pos, m_entries[idx].file_idx) == end_pos)
       continue;
 
-    // Exact match always wins.  Otherwise try to find the closest line > the
-    // desired
-    // line.
-    // FIXME: Maybe want to find the line closest before and the line closest
-    // after and
-    // if they're not in the same function, don't return a match.
+    // Exact match always wins.  Otherwise try to find the closest line >
+    // the desired line. FIXME: Maybe want to find the line closest before
+    // and the line closest after and if they're not in the same function,
+    // don't return a match.
 
     if (m_entries[idx].line < line) {
       continue;
@@ -340,20 +332,18 @@
   size_t best_match = UINT32_MAX;
 
   for (size_t idx = start_idx; idx < count; ++idx) {
-    // Skip line table rows that terminate the previous row (is_terminal_entry
-    // is non-zero)
+    // Skip line table rows that terminate the previous row
+    // (is_terminal_entry is non-zero)
     if (m_entries[idx].is_terminal_entry)
       continue;
 
     if (m_entries[idx].file_idx != file_idx)
       continue;
 
-    // Exact match always wins.  Otherwise try to find the closest line > the
-    // desired
-    // line.
-    // FIXME: Maybe want to find the line closest before and the line closest
-    // after and
-    // if they're not in the same function, don't return a match.
+    // Exact match always wins.  Otherwise try to find the closest line >
+    // the desired line. FIXME: Maybe want to find the line closest before
+    // and the line closest after and if they're not in the same function,
+    // don't return a match.
 
     if (m_entries[idx].line < line) {
       continue;
@@ -389,8 +379,8 @@
     SymbolContext sc(m_comp_unit);
 
     for (size_t idx = 0; idx < count; ++idx) {
-      // Skip line table rows that terminate the previous row (is_terminal_entry
-      // is non-zero)
+      // Skip line table rows that terminate the previous row
+      // (is_terminal_entry is non-zero)
       if (m_entries[idx].is_terminal_entry)
         continue;
 
@@ -486,8 +476,9 @@
       entry_linked_file_addr = entry.file_addr -
                                file_range_entry->GetRangeBase() +
                                file_range_entry->data;
-      // Determine if we need to terminate the previous entry when the previous
-      // entry was not contiguous with this one after being linked.
+      // Determine if we need to terminate the previous entry when the
+      // previous entry was not contiguous with this one after being
+      // linked.
       if (range_changed && prev_file_range_entry) {
         prev_end_entry_linked_file_addr =
             std::min<lldb::addr_t>(entry.file_addr,
@@ -526,14 +517,14 @@
 
     // Now link the current entry
     if (file_range_entry) {
-      // This entry has an address remapping and it needs to have its address
-      // relinked
+      // This entry has an address remapping and it needs to have its
+      // address relinked
       sequence.m_entries.push_back(entry);
       sequence.m_entries.back().file_addr = entry_linked_file_addr;
     }
 
-    // If we have items in the sequence and the last entry is a terminal entry,
-    // insert this sequence into our new line table.
+    // If we have items in the sequence and the last entry is a terminal
+    // entry, insert this sequence into our new line table.
     if (!sequence.m_entries.empty() &&
         sequence.m_entries.back().is_terminal_entry) {
       line_table_ap->InsertSequence(&sequence);
Index: source/Symbol/ObjectFile.cpp
===================================================================
--- source/Symbol/ObjectFile.cpp
+++ source/Symbol/ObjectFile.cpp
@@ -50,10 +50,9 @@
 
       const bool file_exists = file->Exists();
       if (!data_sp) {
-        // We have an object name which most likely means we have
-        // a .o file in a static archive (.a file). Try and see if
-        // we have a cached archive first without reading any data
-        // first
+        // We have an object name which most likely means we have a .o
+        // file in a static archive (.a file). Try and see if we have a
+        // cached archive first without reading any data first
         if (file_exists && module_sp->GetObjectName()) {
           for (uint32_t idx = 0;
                (create_object_container_callback =
@@ -74,8 +73,8 @@
         }
         // Ok, we didn't find any containers that have a named object, now
         // lets read the first 512 bytes from the file so the object file
-        // and object container plug-ins can use these bytes to see if they
-        // can parse this file.
+        // and object container plug-ins can use these bytes to see if
+        // they can parse this file.
         if (file_size > 0) {
           data_sp =
               DataBufferLLVM::CreateSliceFromPath(file->GetPath(), 512, file_offset);
@@ -84,7 +83,8 @@
       }
 
       if (!data_sp || data_sp->GetByteSize() == 0) {
-        // Check for archive file with format "/path/to/archive.a(object.o)"
+        // Check for archive file with format
+        // "/path/to/archive.a(object.o)"
         char path_with_object[PATH_MAX * 2];
         module_sp->GetFileSpec().GetPath(path_with_object,
                                          sizeof(path_with_object));
@@ -97,12 +97,12 @@
           if (file_size > 0) {
             file = &archive_file;
             module_sp->SetFileSpecAndObjectName(archive_file, archive_object);
-            // Check if this is a object container by iterating through all
-            // object
-            // container plugin instances and then trying to get an object file
-            // from the container plugins since we had a name. Also, don't read
-            // ANY data in case there is data cached in the container plug-ins
-            // (like BSD archives caching the contained objects within an file).
+            // Check if this is a object container by iterating through
+            // all object container plugin instances and then trying to
+            // get an object file from the container plugins since we had
+            // a name. Also, don't read ANY data in case there is data
+            // cached in the container plug-ins (like BSD archives caching
+            // the contained objects within an file).
             for (uint32_t idx = 0;
                  (create_object_container_callback =
                       PluginManager::GetObjectContainerCreateCallbackAtIndex(
@@ -120,7 +120,8 @@
                 return object_file_sp;
             }
             // We failed to find any cached object files in the container
-            // plug-ins, so lets read the first 512 bytes and try again below...
+            // plug-ins, so lets read the first 512 bytes and try again
+            // below...
             data_sp = DataBufferLLVM::CreateSliceFromPath(archive_file.GetPath(),
                                                      512, file_offset);
           }
@@ -128,8 +129,8 @@
       }
 
       if (data_sp && data_sp->GetByteSize() > 0) {
-        // Check if this is a normal object file by iterating through
-        // all object file plugin instances.
+        // Check if this is a normal object file by iterating through all
+        // object file plugin instances.
         ObjectFileCreateInstance create_object_file_callback;
         for (uint32_t idx = 0;
              (create_object_file_callback =
@@ -142,9 +143,9 @@
             return object_file_sp;
         }
 
-        // Check if this is a object container by iterating through
-        // all object container plugin instances and then trying to get
-        // an object file from the container.
+        // Check if this is a object container by iterating through all
+        // object container plugin instances and then trying to get an
+        // object file from the container.
         for (uint32_t idx = 0;
              (create_object_container_callback =
                   PluginManager::GetObjectContainerCreateCallbackAtIndex(
@@ -163,8 +164,8 @@
       }
     }
   }
-  // We didn't find it, so clear our shared pointer in case it
-  // contains anything and return an empty shared pointer
+  // We didn't find it, so clear our shared pointer in case it contains
+  // anything and return an empty shared pointer
   object_file_sp.reset();
   return object_file_sp;
 }
@@ -185,8 +186,8 @@
                        static_cast<void *>(process_sp.get()), header_addr);
     uint32_t idx;
 
-    // Check if this is a normal object file by iterating through
-    // all object file plugin instances.
+    // Check if this is a normal object file by iterating through all
+    // object file plugin instances.
     ObjectFileCreateMemoryInstance create_callback;
     for (idx = 0;
          (create_callback =
@@ -200,8 +201,8 @@
     }
   }
 
-  // We didn't find it, so clear our shared pointer in case it
-  // contains anything and return an empty shared pointer
+  // We didn't find it, so clear our shared pointer in case it contains
+  // anything and return an empty shared pointer
   object_file_sp.reset();
   return object_file_sp;
 }
@@ -376,11 +377,9 @@
           case eSectionTypeOther:
             return eAddressClassUnknown;
           case eSectionTypeAbsoluteAddress:
-            // In case of absolute sections decide the address class based on
-            // the symbol
-            // type because the section type isn't specify if it is a code or a
-            // data
-            // section.
+            // In case of absolute sections decide the address class based
+            // on the symbol type because the section type isn't specify
+            // if it is a code or a data section.
             break;
           }
         }
@@ -468,17 +467,16 @@
 
 size_t ObjectFile::GetData(lldb::offset_t offset, size_t length,
                            DataExtractor &data) const {
-  // The entire file has already been mmap'ed into m_data, so just copy from
-  // there
-  // as the back mmap buffer will be shared with shared pointers.
+  // The entire file has already been mmap'ed into m_data, so just copy
+  // from there as the back mmap buffer will be shared with shared
+  // pointers.
   return data.SetData(m_data, offset, length);
 }
 
 size_t ObjectFile::CopyData(lldb::offset_t offset, size_t length,
                             void *dst) const {
-  // The entire file has already been mmap'ed into m_data, so just copy from
-  // there
-  // Note that the data remains in target byte order.
+  // The entire file has already been mmap'ed into m_data, so just copy
+  // from there Note that the data remains in target byte order.
   return m_data.CopyData(offset, length, dst);
 }
 
@@ -558,8 +556,8 @@
     return GetData(section->GetFileOffset(), section->GetFileSize(),
                    section_data);
   } else {
-    // The object file now contains a full mmap'ed copy of the object file data,
-    // so just use this
+    // The object file now contains a full mmap'ed copy of the object file
+    // data, so just use this
     if (!section->IsRelocated())
       RelocateSection(section);
 
Index: source/Symbol/Symbol.cpp
===================================================================
--- source/Symbol/Symbol.cpp
+++ source/Symbol/Symbol.cpp
@@ -122,9 +122,9 @@
 
 ConstString Symbol::GetReExportedSymbolName() const {
   if (m_type == eSymbolTypeReExported) {
-    // For eSymbolTypeReExported, the "const char *" from a ConstString
-    // is used as the offset in the address range base address. We can
-    // then make this back into a string that is the re-exported name.
+    // For eSymbolTypeReExported, the "const char *" from a ConstString is
+    // used as the offset in the address range base address. We can then
+    // make this back into a string that is the re-exported name.
     intptr_t str_ptr = m_addr_range.GetBaseAddress().GetOffset();
     if (str_ptr != 0)
       return ConstString((const char *)str_ptr);
@@ -136,9 +136,9 @@
 
 FileSpec Symbol::GetReExportedSymbolSharedLibrary() const {
   if (m_type == eSymbolTypeReExported) {
-    // For eSymbolTypeReExported, the "const char *" from a ConstString
-    // is used as the offset in the address range base address. We can
-    // then make this back into a string that is the re-exported name.
+    // For eSymbolTypeReExported, the "const char *" from a ConstString is
+    // used as the offset in the address range base address. We can then
+    // make this back into a string that is the re-exported name.
     intptr_t str_ptr = m_addr_range.GetByteSize();
     if (str_ptr != 0)
       return FileSpec((const char *)str_ptr, false);
@@ -148,15 +148,15 @@
 
 void Symbol::SetReExportedSymbolName(const ConstString &name) {
   SetType(eSymbolTypeReExported);
-  // For eSymbolTypeReExported, the "const char *" from a ConstString
-  // is used as the offset in the address range base address.
+  // For eSymbolTypeReExported, the "const char *" from a ConstString is
+  // used as the offset in the address range base address.
   m_addr_range.GetBaseAddress().SetOffset((uintptr_t)name.GetCString());
 }
 
 bool Symbol::SetReExportedSymbolSharedLibrary(const FileSpec &fspec) {
   if (m_type == eSymbolTypeReExported) {
-    // For eSymbolTypeReExported, the "const char *" from a ConstString
-    // is used as the offset in the address range base address.
+    // For eSymbolTypeReExported, the "const char *" from a ConstString is
+    // used as the offset in the address range base address.
     m_addr_range.SetByteSize(
         (uintptr_t)ConstString(fspec.GetPath().c_str()).GetCString());
     return true;
@@ -261,10 +261,9 @@
       const Address &base_address = m_addr_range.GetBaseAddress();
       Function *function = base_address.CalculateSymbolContextFunction();
       if (function) {
-        // Functions have line entries which can also potentially have end of
-        // prologue information.
-        // So if this symbol points to a function, use the prologue information
-        // from there.
+        // Functions have line entries which can also potentially have end
+        // of prologue information. So if this symbol points to a
+        // function, use the prologue information from there.
         m_type_data = function->GetPrologueByteSize();
       } else {
         ModuleSP module_sp(base_address.GetModule());
@@ -280,10 +279,9 @@
             Address addr(base_address);
             addr.Slide(m_type_data);
 
-            // Check the first few instructions and look for one that has a line
-            // number that is
-            // different than the first entry. This is also done in
-            // Function::GetPrologueByteSize().
+            // Check the first few instructions and look for one that has
+            // a line number that is different than the first entry. This
+            // is also done in Function::GetPrologueByteSize().
             uint16_t total_offset = m_type_data;
             for (int idx = 0; idx < 6; ++idx) {
               SymbolContext sc_temp;
@@ -293,8 +291,8 @@
               if (!(resolved_flags & eSymbolContextLineEntry))
                 break;
 
-              // If this line number is different than our first one, use it and
-              // we're done.
+              // If this line number is different than our first one, use
+              // it and we're done.
               if (sc_temp.line_entry.line != sc.line_entry.line) {
                 m_type_data = total_offset;
                 break;
@@ -308,18 +306,17 @@
                 break;
             }
 
-            // Sanity check - this may be a function in the middle of code that
-            // has debug information, but
-            // not for this symbol.  So the line entries surrounding us won't
-            // lie inside our function.
-            // In that case, the line entry will be bigger than we are, so we do
-            // that quick check and
-            // if that is true, we just return 0.
+            // Sanity check - this may be a function in the middle of code
+            // that has debug information, but not for this symbol.  So
+            // the line entries surrounding us won't lie inside our
+            // function. In that case, the line entry will be bigger than
+            // we are, so we do that quick check and if that is true, we
+            // just return 0.
             if (m_type_data >= m_addr_range.GetByteSize())
               m_type_data = 0;
           } else {
-            // TODO: expose something in Process to figure out the
-            // size of a function prologue.
+            // TODO: expose something in Process to figure out the size of
+            // a function prologue.
             m_type_data = 0;
           }
         }
@@ -379,7 +376,8 @@
 }
 
 void Symbol::CalculateSymbolContext(SymbolContext *sc) {
-  // Symbols can reconstruct the symbol and the module in the symbol context
+  // Symbols can reconstruct the symbol and the module in the symbol
+  // context
   sc->symbol = this;
   if (ValueIsAddress())
     sc->module_sp = GetAddressRef().GetModule();
@@ -421,17 +419,16 @@
     module_sp = target.GetImages().FindFirstModule(module_spec);
     if (!module_sp) {
       // Next try and find the module by basename in case environment
-      // variables or other runtime trickery causes shared libraries
-      // to be loaded from alternate paths
+      // variables or other runtime trickery causes shared libraries to be
+      // loaded from alternate paths
       module_spec.GetFileSpec().GetDirectory().Clear();
       module_sp = target.GetImages().FindFirstModule(module_spec);
     }
   }
 
   if (module_sp) {
-    // There should not be cycles in the reexport list, but we don't want to
-    // crash if there are so make sure
-    // we haven't seen this before:
+    // There should not be cycles in the reexport list, but we don't want
+    // to crash if there are so make sure we haven't seen this before:
     if (!seen_modules.AppendIfNeeded(module_sp))
       return nullptr;
 
@@ -449,8 +446,8 @@
       }
     }
     // If we didn't find the symbol in this module, it may be because this
-    // module re-exports some
-    // whole other library.  We have to search those as well:
+    // module re-exports some whole other library.  We have to search
+    // those as well:
     seen_modules.Append(module_sp);
 
     FileSpecList reexported_libraries =
Index: source/Symbol/SymbolContext.cpp
===================================================================
--- source/Symbol/SymbolContext.cpp
+++ source/Symbol/SymbolContext.cpp
@@ -358,9 +358,8 @@
   *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)
+  // 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();
@@ -474,16 +473,16 @@
     // this block or one of this blocks parents is an inlined function.
     Block *curr_inlined_block = block->GetContainingInlinedBlock();
     if (curr_inlined_block) {
-      // "this->block" is contained in an inline function block, so to
-      // get the scope above the inlined block, we get the parent of the
+      // "this->block" is contained in an inline function block, so to get
+      // the scope above the inlined block, we get the parent of the
       // inlined block itself
       Block *next_frame_block = curr_inlined_block->GetParent();
       // Now calculate the symbol context of the containing block
       next_frame_block->CalculateSymbolContext(&next_frame_sc);
 
-      // If we get here we weren't able to find the return line entry using the
-      // nesting of the blocks and
-      // the line table.  So just use the call site info from our inlined block.
+      // If we get here we weren't able to find the return line entry
+      // using the nesting of the blocks and the line table.  So just use
+      // the call site info from our inlined block.
 
       AddressRange range;
       if (curr_inlined_block->GetRangeContainingAddress(curr_frame_pc, range)) {
@@ -550,22 +549,22 @@
 Block *SymbolContext::GetFunctionBlock() {
   if (function) {
     if (block) {
-      // If this symbol context has a block, check to see if this block
-      // is itself, or is contained within a block with inlined function
+      // If this symbol context has a block, check to see if this block is
+      // itself, or is contained within a block with inlined function
       // information. If so, then the inlined block is the block that
       // defines the function.
       Block *inlined_block = block->GetContainingInlinedBlock();
       if (inlined_block)
         return inlined_block;
 
-      // The block in this symbol context is not inside an inlined
-      // block, so the block that defines the function is the function's
-      // top level block, which is returned below.
+      // The block in this symbol context is not inside an inlined block,
+      // so the block that defines the function is the function's top
+      // level block, which is returned below.
     }
 
     // There is no block information in this symbol context, so we must
-    // assume that the block that is desired is the top level block of
-    // the function itself.
+    // assume that the block that is desired is the top level block of the
+    // function itself.
     return &function->GetBlock(true);
   }
   return nullptr;
@@ -831,9 +830,9 @@
             case eSymbolTypeObjCMetaClass:
             case eSymbolTypeObjCIVar:
               if (symbol->GetDemangledNameIsSynthesized()) {
-                // If the demangled name was synthesized, then don't use it
-                // for expressions. Only let the symbol match if the mangled
-                // named matches for these symbols.
+                // If the demangled name was synthesized, then don't use
+                // it for expressions. Only let the symbol match if the
+                // mangled named matches for these symbols.
                 if (symbol->GetMangled().GetMangledName() != name)
                   break;
               }
@@ -861,8 +860,8 @@
                     target.GetImages().FindFirstModule(reexport_module_spec);
                   }
                 }
-                // Don't allow us to try and resolve a re-exported symbol if it is
-                // the same as the current symbol
+                // Don't allow us to try and resolve a re-exported symbol
+                // if it is the same as the current symbol
                 if (name == symbol->GetReExportedSymbolName() &&
                     module == reexport_module_sp.get())
                   return nullptr;
@@ -1011,10 +1010,9 @@
       m_module_spec.assign(spec_string);
   } break;
   case eFileSpecified:
-    // CompUnits can't necessarily be resolved here, since an inlined function
-    // might show up in
-    // a number of CompUnits.  Instead we just convert to a FileSpec and store
-    // it away.
+    // CompUnits can't necessarily be resolved here, since an inlined
+    // function might show up in a number of CompUnits.  Instead we just
+    // convert to a FileSpec and store it away.
     m_file_spec_ap.reset(new FileSpec(spec_string, false));
     m_type |= eFileSpecified;
     break;
@@ -1079,8 +1077,8 @@
   }
   if (m_type & eFileSpecified) {
     if (m_file_spec_ap.get()) {
-      // If we don't have a block or a comp_unit, then we aren't going to match
-      // a source file.
+      // If we don't have a block or a comp_unit, then we aren't going to
+      // match a source file.
       if (sc.block == nullptr && sc.comp_unit == nullptr)
         return false;
 
@@ -1111,8 +1109,8 @@
   }
 
   if (m_type & eFunctionSpecified) {
-    // First check the current block, and if it is inlined, get the inlined
-    // function name:
+    // First check the current block, and if it is inlined, get the
+    // inlined function name:
     bool was_inlined = false;
     ConstString func_name(m_function_spec.c_str());
 
@@ -1309,8 +1307,8 @@
                            // return true
 
             if (function_sc.symbol == nullptr) {
-              // We successfully merged this symbol into an existing symbol
-              // context
+              // We successfully merged this symbol into an existing
+              // symbol context
               m_symbol_contexts[i].symbol = symbol_sc.symbol;
               return true;
             }
Index: source/Symbol/SymbolFile.cpp
===================================================================
--- source/Symbol/SymbolFile.cpp
+++ source/Symbol/SymbolFile.cpp
@@ -29,9 +29,8 @@
   std::unique_ptr<SymbolFile> best_symfile_ap;
   if (obj_file != nullptr) {
 
-    // We need to test the abilities of this section list. So create what it
-    // would
-    // be with this new obj_file.
+    // We need to test the abilities of this section list. So create what
+    // it would be with this new obj_file.
     lldb::ModuleSP module_sp(obj_file->GetModule());
     if (module_sp) {
       // Default to the main module section list.
@@ -60,8 +59,8 @@
         if (sym_file_abilities > best_symfile_abilities) {
           best_symfile_abilities = sym_file_abilities;
           best_symfile_ap.reset(curr_symfile_ap.release());
-          // If any symbol file parser has all of the abilities, then
-          // we should just stop looking.
+          // If any symbol file parser has all of the abilities, then we
+          // should just stop looking.
           if ((kAllAbilities & sym_file_abilities) == kAllAbilities)
             break;
         }
Index: source/Symbol/SymbolVendor.cpp
===================================================================
--- source/Symbol/SymbolVendor.cpp
+++ source/Symbol/SymbolVendor.cpp
@@ -26,9 +26,9 @@
 //----------------------------------------------------------------------
 // FindPlugin
 //
-// Platforms can register a callback to use when creating symbol
-// vendors to allow for complex debug information file setups, and to
-// also allow for finding separate debug information files.
+// Platforms can register a callback to use when creating symbol vendors
+// to allow for complex debug information file setups, and to also allow
+// for finding separate debug information files.
 //----------------------------------------------------------------------
 SymbolVendor *SymbolVendor::FindPlugin(const lldb::ModuleSP &module_sp,
                                        lldb_private::Stream *feedback_strm) {
@@ -45,8 +45,8 @@
       return instance_ap.release();
     }
   }
-  // The default implementation just tries to create debug information using the
-  // file representation for the module.
+  // The default implementation just tries to create debug information
+  // using the file representation for the module.
   instance_ap.reset(new SymbolVendor(module_sp));
   if (instance_ap.get()) {
     ObjectFile *objfile = module_sp->GetObjectFile();
@@ -88,11 +88,11 @@
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     const size_t num_compile_units = GetNumCompileUnits();
     if (idx < num_compile_units) {
-      // Fire off an assertion if this compile unit already exists for now.
-      // The partial parsing should take care of only setting the compile
-      // unit once, so if this assertion fails, we need to make sure that
-      // we don't have a race condition, or have a second parse of the same
-      // compile unit.
+      // Fire off an assertion if this compile unit already exists for
+      // now. The partial parsing should take care of only setting the
+      // compile unit once, so if this assertion fails, we need to make
+      // sure that we don't have a race condition, or have a second parse
+      // of the same compile unit.
       assert(m_compile_units[idx].get() == nullptr);
       m_compile_units[idx] = cu_sp;
       return true;
Index: source/Symbol/Symtab.cpp
===================================================================
--- source/Symbol/Symtab.cpp
+++ source/Symbol/Symtab.cpp
@@ -34,21 +34,21 @@
 Symtab::~Symtab() {}
 
 void Symtab::Reserve(size_t count) {
-  // Clients should grab the mutex from this symbol table and lock it manually
-  // when calling this function to avoid performance issues.
+  // Clients should grab the mutex from this symbol table and lock it
+  // manually when calling this function to avoid performance issues.
   m_symbols.reserve(count);
 }
 
 Symbol *Symtab::Resize(size_t count) {
-  // Clients should grab the mutex from this symbol table and lock it manually
-  // when calling this function to avoid performance issues.
+  // Clients should grab the mutex from this symbol table and lock it
+  // manually when calling this function to avoid performance issues.
   m_symbols.resize(count);
   return m_symbols.empty() ? nullptr : &m_symbols[0];
 }
 
 uint32_t Symtab::AddSymbol(const Symbol &symbol) {
-  // Clients should grab the mutex from this symbol table and lock it manually
-  // when calling this function to avoid performance issues.
+  // Clients should grab the mutex from this symbol table and lock it
+  // manually when calling this function to avoid performance issues.
   uint32_t symbol_idx = m_symbols.size();
   m_name_to_index.Clear();
   m_file_addr_to_index.Clear();
@@ -100,9 +100,9 @@
     } break;
 
     case eSortOrderByName: {
-      // Although we maintain a lookup by exact name map, the table
-      // isn't sorted by name. So we must make the ordered symbol list
-      // up ourselves.
+      // Although we maintain a lookup by exact name map, the table isn't
+      // sorted by name. So we must make the ordered symbol list up
+      // ourselves.
       s->PutCString(" (sorted by name):\n");
       DumpSymbolHeader(s);
       typedef std::multimap<const char *, const Symbol *,
@@ -198,16 +198,16 @@
 }
 
 Symbol *Symtab::SymbolAtIndex(size_t idx) {
-  // Clients should grab the mutex from this symbol table and lock it manually
-  // when calling this function to avoid performance issues.
+  // Clients should grab the mutex from this symbol table and lock it
+  // manually when calling this function to avoid performance issues.
   if (idx < m_symbols.size())
     return &m_symbols[idx];
   return nullptr;
 }
 
 const Symbol *Symtab::SymbolAtIndex(size_t idx) const {
-  // Clients should grab the mutex from this symbol table and lock it manually
-  // when calling this function to avoid performance issues.
+  // Clients should grab the mutex from this symbol table and lock it
+  // manually when calling this function to avoid performance issues.
   if (idx < m_symbols.size())
     return &m_symbols[idx];
   return nullptr;
@@ -255,11 +255,11 @@
     for (entry.value = 0; entry.value < num_symbols; ++entry.value) {
       const Symbol *symbol = &m_symbols[entry.value];
 
-      // Don't let trampolines get into the lookup by name map
-      // If we ever need the trampoline symbols to be searchable by name
-      // we can remove this and then possibly add a new bool to any of the
-      // Symtab functions that lookup symbols by name to indicate if they
-      // want trampolines.
+      // Don't let trampolines get into the lookup by name map If we ever
+      // need the trampoline symbols to be searchable by name we can
+      // remove this and then possibly add a new bool to any of the Symtab
+      // functions that lookup symbols by name to indicate if they want
+      // trampolines.
       if (symbol->IsTrampoline())
         continue;
 
@@ -269,8 +269,8 @@
         m_name_to_index.Append(entry);
 
         if (symbol->ContainsLinkerAnnotations()) {
-          // If the symbol has linker annotations, also add the version without
-          // the annotations.
+          // If the symbol has linker annotations, also add the version
+          // without the annotations.
           entry.cstring = ConstString(m_objfile->StripLinkerSymbolAnnotations(
                                         entry.cstring.GetStringRef()));
           m_name_to_index.Append(entry);
@@ -293,44 +293,44 @@
                 mangled.GetDemangledName(lldb::eLanguageTypeC_plus_plus));
             entry.cstring = ConstString(cxx_method.GetBasename());
             if (entry.cstring) {
-              // ConstString objects permanently store the string in the pool so
-              // calling
-              // GetCString() on the value gets us a const char * that will
-              // never go away
+              // ConstString objects permanently store the string in the
+              // pool so calling GetCString() on the value gets us a const
+              // char * that will never go away
               const char *const_context =
                   ConstString(cxx_method.GetContext()).GetCString();
 
               if (!const_context || const_context[0] == 0) {
-                // No context for this function so this has to be a basename
+                // No context for this function so this has to be a
+                // basename
                 m_basename_to_index.Append(entry);
-                // If there is no context (no namespaces or class scopes that
-                // come before the function name) then this also could be a
-                // fullname.
+                // If there is no context (no namespaces or class scopes
+                // that come before the function name) then this also
+                // could be a fullname.
                 m_name_to_index.Append(entry);
               } else {
                 entry_ref = entry.cstring.GetStringRef();
                 if (entry_ref[0] == '~' ||
                     !cxx_method.GetQualifiers().empty()) {
-                  // The first character of the demangled basename is '~' which
-                  // means we have a class destructor. We can use this information
-                  // to help us know what is a class and what isn't.
+                  // The first character of the demangled basename is '~'
+                  // which means we have a class destructor. We can use
+                  // this information to help us know what is a class and
+                  // what isn't.
                   if (class_contexts.find(const_context) == class_contexts.end())
                     class_contexts.insert(const_context);
                   m_method_to_index.Append(entry);
                 } else {
                   if (class_contexts.find(const_context) !=
                       class_contexts.end()) {
-                    // The current decl context is in our "class_contexts" which
-                    // means
-                    // this is a method on a class
+                    // The current decl context is in our "class_contexts"
+                    // which means this is a method on a class
                     m_method_to_index.Append(entry);
                   } else {
-                    // We don't know if this is a function basename or a method,
-                    // so put it into a temporary collection so once we are done
-                    // we can look in class_contexts to see if each entry is a
-                    // class
-                    // or just a function and will put any remaining items into
-                    // m_method_to_index or m_basename_to_index as needed
+                    // We don't know if this is a function basename or a
+                    // method, so put it into a temporary collection so
+                    // once we are done we can look in class_contexts to
+                    // see if each entry is a class or just a function and
+                    // will put any remaining items into m_method_to_index
+                    // or m_basename_to_index as needed
                     mangled_name_to_index.Append(entry);
                     symbol_contexts[entry.value] = const_context;
                   }
@@ -346,16 +346,16 @@
         m_name_to_index.Append(entry);
 
         if (symbol->ContainsLinkerAnnotations()) {
-          // If the symbol has linker annotations, also add the version without
-          // the annotations.
+          // If the symbol has linker annotations, also add the version
+          // without the annotations.
           entry.cstring = ConstString(m_objfile->StripLinkerSymbolAnnotations(
                                         entry.cstring.GetStringRef()));
           m_name_to_index.Append(entry);
         }
       }
 
-      // If the demangled name turns out to be an ObjC name, and
-      // is a category name, add the version without categories to the index
+      // If the demangled name turns out to be an ObjC name, and is a
+      // category name, add the version without categories to the index
       // too.
       ObjCLanguage::MethodName objc_method(entry.cstring.GetStringRef(), true);
       if (objc_method.IsValid(true)) {
@@ -382,9 +382,8 @@
                   class_contexts.end()) {
             m_method_to_index.Append(entry);
           } else {
-            // If we got here, we have something that had a context (was inside
-            // a namespace or class)
-            // yet we don't know if the entry
+            // If we got here, we have something that had a context (was
+            // inside a namespace or class) yet we don't know if the entry
             m_method_to_index.Append(entry);
             m_basename_to_index.Append(entry);
           }
@@ -519,21 +518,16 @@
   const std::vector<Symbol> &symbols;
   std::vector<lldb::addr_t> &addr_cache;
 
-  // Getting from the symbol to the Address to the File Address involves some
-  // work.
-  // Since there are potentially many symbols here, and we're using this for
-  // sorting so
-  // we're going to be computing the address many times, cache that in
-  // addr_cache.
-  // The array passed in has to be the same size as the symbols array passed
-  // into the
-  // member variable symbols, and should be initialized with
-  // LLDB_INVALID_ADDRESS.
-  // NOTE: You have to make addr_cache externally and pass it in because
-  // std::stable_sort
-  // makes copies of the comparator it is initially passed in, and you end up
-  // spending
-  // huge amounts of time copying this array...
+  // Getting from the symbol to the Address to the File Address involves
+  // some work. Since there are potentially many symbols here, and we're
+  // using this for sorting so we're going to be computing the address
+  // many times, cache that in addr_cache. The array passed in has to be
+  // the same size as the symbols array passed into the member variable
+  // symbols, and should be initialized with LLDB_INVALID_ADDRESS. NOTE:
+  // You have to make addr_cache externally and pass it in because
+  // std::stable_sort makes copies of the comparator it is initially
+  // passed in, and you end up spending huge amounts of time copying this
+  // array...
 
   SymbolIndexComparator(const std::vector<Symbol> &s,
                         std::vector<lldb::addr_t> &a)
@@ -580,12 +574,10 @@
   if (indexes.size() <= 1)
     return;
 
-  // Sort the indexes in place using std::stable_sort.
-  // NOTE: The use of std::stable_sort instead of std::sort here is strictly for
-  // performance,
-  // not correctness.  The indexes vector tends to be "close" to sorted, which
-  // the
-  // stable sort handles better.
+  // Sort the indexes in place using std::stable_sort. NOTE: The use of
+  // std::stable_sort instead of std::sort here is strictly for
+  // performance, not correctness.  The indexes vector tends to be "close"
+  // to sorted, which the stable sort handles better.
 
   std::vector<lldb::addr_t> addr_cache(m_symbols.size(), LLDB_INVALID_ADDRESS);
 
@@ -758,8 +750,8 @@
     InitNameIndexes();
 
   if (name) {
-    // The string table did have a string that matched, but we need
-    // to check the symbols and match the symbol_type if any was given.
+    // The string table did have a string that matched, but we need to
+    // check the symbols and match the symbol_type if any was given.
     AppendSymbolIndexesWithNameAndType(name, symbol_type, symbol_indexes);
   }
   return symbol_indexes.size();
@@ -778,8 +770,8 @@
     InitNameIndexes();
 
   if (name) {
-    // The string table did have a string that matched, but we need
-    // to check the symbols and match the symbol_type if any was given.
+    // The string table did have a string that matched, but we need to
+    // check the symbols and match the symbol_type if any was given.
     AppendSymbolIndexesWithNameAndType(name, symbol_type, symbol_debug_type,
                                        symbol_visibility, symbol_indexes);
   }
@@ -810,8 +802,8 @@
 
   if (name) {
     std::vector<uint32_t> matching_indexes;
-    // The string table did have a string that matched, but we need
-    // to check the symbols and match the symbol_type if any was given.
+    // The string table did have a string that matched, but we need to
+    // check the symbols and match the symbol_type if any was given.
     if (AppendSymbolIndexesWithNameAndType(name, symbol_type, symbol_debug_type,
                                            symbol_visibility,
                                            matching_indexes)) {
@@ -845,8 +837,8 @@
     if (sect_sp) {
       SectionList &child_sectlist = sect_sp->GetChildren();
 
-      // If this section has children, add the children to the RangeVector.
-      // Else add this section to the RangeVector.
+      // If this section has children, add the children to the
+      // RangeVector. Else add this section to the RangeVector.
       if (child_sectlist.GetNumSections(0) > 0) {
         AddSectionsToRangeMap(&child_sectlist, section_ranges);
       } else {
@@ -883,11 +875,11 @@
     if (num_entries > 0) {
       m_file_addr_to_index.Sort();
 
-      // Create a RangeVector with the start & size of all the sections for
-      // this objfile.  We'll need to check this for any FileRangeToIndexMap
-      // entries with an uninitialized size, which could potentially be a
-      // large number so reconstituting the weak pointer is busywork when it
-      // is invariant information.
+      // Create a RangeVector with the start & size of all the sections
+      // for this objfile.  We'll need to check this for any
+      // FileRangeToIndexMap entries with an uninitialized size, which
+      // could potentially be a large number so reconstituting the weak
+      // pointer is busywork when it is invariant information.
       SectionList *sectlist = m_objfile->GetSectionList();
       RangeVector<addr_t, addr_t> section_ranges;
       if (sectlist) {
@@ -895,10 +887,10 @@
         section_ranges.Sort();
       }
 
-      // Iterate through the FileRangeToIndexMap and fill in the size for any
-      // entries that didn't already have a size from the Symbol (e.g. if we
-      // have a plain linker symbol with an address only, instead of debug info
-      // where we get an address and a size and a type, etc.)
+      // Iterate through the FileRangeToIndexMap and fill in the size for
+      // any entries that didn't already have a size from the Symbol (e.g.
+      // if we have a plain linker symbol with an address only, instead of
+      // debug info where we get an address and a size and a type, etc.)
       for (size_t i = 0; i < num_entries; i++) {
         FileRangeToIndexMap::Entry *entry =
             m_file_addr_to_index.GetMutableEntryAtIndex(i);
@@ -907,7 +899,8 @@
           const RangeVector<addr_t, addr_t>::Entry *containing_section =
               section_ranges.FindEntryThatContains(curr_base_addr);
 
-          // Use the end of the section as the default max size of the symbol
+          // Use the end of the section as the default max size of the
+          // symbol
           addr_t sym_size = 0;
           if (containing_section) {
             sym_size =
@@ -922,9 +915,8 @@
             if (next_base_addr > curr_base_addr) {
               addr_t size_to_next_symbol = next_base_addr - curr_base_addr;
 
-              // Take the difference between this symbol and the next one as its
-              // size,
-              // if it is less than the size of the section.
+              // Take the difference between this symbol and the next one
+              // as its size, if it is less than the size of the section.
               if (sym_size == 0 || size_to_next_symbol < sym_size) {
                 sym_size = size_to_next_symbol;
               }
@@ -958,8 +950,7 @@
 
     for (size_t i = 0; i < num_entries; ++i) {
       // The entries in the m_file_addr_to_index have calculated the sizes
-      // already
-      // so we will use this size if we need to.
+      // already so we will use this size if we need to.
       const FileRangeToIndexMap::Entry &entry =
           m_file_addr_to_index.GetEntryRef(i);
 
@@ -1086,8 +1077,8 @@
   }
 
   if (name_type_mask & eFunctionNameTypeBase) {
-    // From mangled names we can't tell what is a basename and what
-    // is a method name, so we just treat them the same
+    // From mangled names we can't tell what is a basename and what is a
+    // method name, so we just treat them the same
     if (!m_name_indexes_computed)
       InitNameIndexes();
 
Index: source/Symbol/Type.cpp
===================================================================
--- source/Symbol/Type.cpp
+++ source/Symbol/Type.cpp
@@ -387,8 +387,8 @@
 bool Type::ReadFromMemory(ExecutionContext *exe_ctx, lldb::addr_t addr,
                           AddressType address_type, DataExtractor &data) {
   if (address_type == eAddressTypeFile) {
-    // Can't convert a file address to anything valid without more
-    // context (which Module it came from)
+    // Can't convert a file address to anything valid without more context
+    // (which Module it came from)
     return false;
   }
 
@@ -532,11 +532,10 @@
       }
     }
 
-    // When we have a EncodingUID, our "m_flags.compiler_type_resolve_state" is
-    // set to eResolveStateUnresolved
-    // so we need to update it to say that we now have a forward declaration
-    // since that is what we created
-    // above.
+    // When we have a EncodingUID, our
+    // "m_flags.compiler_type_resolve_state" is set to
+    // eResolveStateUnresolved so we need to update it to say that we now
+    // have a forward declaration since that is what we created above.
     if (m_compiler_type.IsValid())
       m_flags.compiler_type_resolve_state = eResolveStateForward;
   }
@@ -549,15 +548,15 @@
         m_flags.compiler_type_resolve_state < compiler_type_resolve_state) {
       m_flags.compiler_type_resolve_state = eResolveStateFull;
       if (!m_compiler_type.IsDefined()) {
-        // We have a forward declaration, we need to resolve it to a complete
-        // definition.
+        // We have a forward declaration, we need to resolve it to a
+        // complete definition.
         m_symbol_file->CompleteType(m_compiler_type);
       }
     }
   }
 
-  // If we have an encoding type, then we need to make sure it is
-  // resolved appropriately.
+  // If we have an encoding type, then we need to make sure it is resolved
+  // appropriately.
   if (m_encoding_uid != LLDB_INVALID_UID) {
     if (encoding_type == nullptr)
       encoding_type = GetEncodingType();
@@ -847,39 +846,32 @@
 }
 
 bool TypeImpl::CheckModule(lldb::ModuleSP &module_sp) const {
-  // Check if we have a module for this type. If we do and the shared pointer is
-  // can be successfully initialized with m_module_wp, return true. Else return
-  // false
-  // if we didn't have a module, or if we had a module and it has been deleted.
-  // Any
-  // functions doing anything with a TypeSP in this TypeImpl class should call
-  // this
-  // function and only do anything with the ivars if this function returns true.
-  // If
-  // we have a module, the "module_sp" will be filled in with a strong reference
-  // to the
-  // module so that the module will at least stay around long enough for the
-  // type
-  // query to succeed.
+  // Check if we have a module for this type. If we do and the shared
+  // pointer is can be successfully initialized with m_module_wp, return
+  // true. Else return false if we didn't have a module, or if we had a
+  // module and it has been deleted. Any functions doing anything with a
+  // TypeSP in this TypeImpl class should call this function and only do
+  // anything with the ivars if this function returns true. If we have a
+  // module, the "module_sp" will be filled in with a strong reference to
+  // the module so that the module will at least stay around long enough
+  // for the type query to succeed.
   module_sp = m_module_wp.lock();
   if (!module_sp) {
     lldb::ModuleWP empty_module_wp;
-    // If either call to "std::weak_ptr::owner_before(...) value returns true,
-    // this
-    // indicates that m_module_wp once contained (possibly still does) a
-    // reference
-    // to a valid shared pointer. This helps us know if we had a valid reference
-    // to
-    // a section which is now invalid because the module it was in was deleted
+    // If either call to "std::weak_ptr::owner_before(...) value returns
+    // true, this indicates that m_module_wp once contained (possibly
+    // still does) a reference to a valid shared pointer. This helps us
+    // know if we had a valid reference to a section which is now invalid
+    // because the module it was in was deleted
     if (empty_module_wp.owner_before(m_module_wp) ||
         m_module_wp.owner_before(empty_module_wp)) {
       // m_module_wp had a valid reference to a module, but all strong
-      // references
-      // have been released and the module has been deleted
+      // references have been released and the module has been deleted
       return false;
     }
   }
-  // We either successfully locked the module, or didn't have one to begin with
+  // We either successfully locked the module, or didn't have one to begin
+  // with
   return true;
 }
 
Index: source/Symbol/TypeList.cpp
===================================================================
--- source/Symbol/TypeList.cpp
+++ source/Symbol/TypeList.cpp
@@ -32,7 +32,8 @@
 TypeList::~TypeList() {}
 
 void TypeList::Insert(const TypeSP &type_sp) {
-  // Just push each type on the back for now. We will worry about uniquing later
+  // Just push each type on the back for now. We will worry about uniquing
+  // later
   if (type_sp)
     m_types.push_back(type_sp);
 }
@@ -69,9 +70,9 @@
 
 uint32_t TypeList::GetSize() const { return m_types.size(); }
 
-// GetTypeAtIndex isn't used a lot for large type lists, currently only for
-// type lists that are returned for "image dump -t TYPENAME" commands and other
-// simple symbol queries that grab the first result...
+// GetTypeAtIndex isn't used a lot for large type lists, currently only
+// for type lists that are returned for "image dump -t TYPENAME" commands
+// and other simple symbol queries that grab the first result...
 
 TypeSP TypeList::GetTypeAtIndex(uint32_t idx) {
   iterator pos, end;
@@ -123,10 +124,10 @@
 void TypeList::RemoveMismatchedTypes(const std::string &type_scope,
                                      const std::string &type_basename,
                                      TypeClass type_class, bool exact_match) {
-  // Our "collection" type currently is a std::map which doesn't
-  // have any good way to iterate and remove items from the map
-  // so we currently just make a new list and add all of the matching
-  // types to it, and then swap it into m_types at the end
+  // Our "collection" type currently is a std::map which doesn't have any
+  // good way to iterate and remove items from the map so we currently
+  // just make a new list and add all of the matching types to it, and
+  // then swap it into m_types at the end
   collection matching_types;
 
   iterator pos, end = m_types.end();
@@ -160,20 +161,17 @@
               const size_t type_scope_pos = match_type_scope.rfind(type_scope);
               if (type_scope_pos == match_type_scope_size - type_scope_size) {
                 if (type_scope_pos >= 2) {
-                  // Our match scope ends with the type scope we were looking
-                  // for,
-                  // but we need to make sure what comes before the matching
-                  // type scope is a namespace boundary in case we are trying to
+                  // Our match scope ends with the type scope we were
+                  // looking for, but we need to make sure what comes
+                  // before the matching type scope is a namespace
+                  // boundary in case we are trying to match:
+                  // type_basename = "d" type_scope = "b::c::" We want to
                   // match:
-                  // type_basename = "d"
-                  // type_scope = "b::c::"
-                  // We want to match:
                   //  match_type_scope "a::b::c::"
                   // But not:
                   //  match_type_scope "a::bb::c::"
                   // So below we make sure what comes before "b::c::" in
-                  // match_type_scope
-                  // is "::", or the namespace boundary
+                  // match_type_scope is "::", or the namespace boundary
                   if (match_type_scope[type_scope_pos - 1] == ':' &&
                       match_type_scope[type_scope_pos - 2] == ':') {
                     keep_match = true;
@@ -184,9 +182,9 @@
           }
         }
       } else {
-        // The type we are currently looking at doesn't exists
-        // in a namespace or class, so it only matches if there
-        // is no type scope...
+        // The type we are currently looking at doesn't exists in a
+        // namespace or class, so it only matches if there is no type
+        // scope...
         keep_match =
             type_scope.empty() && type_basename.compare(match_type_name) == 0;
       }
@@ -203,10 +201,10 @@
   if (type_class == eTypeClassAny)
     return;
 
-  // Our "collection" type currently is a std::map which doesn't
-  // have any good way to iterate and remove items from the map
-  // so we currently just make a new list and add all of the matching
-  // types to it, and then swap it into m_types at the end
+  // Our "collection" type currently is a std::map which doesn't have any
+  // good way to iterate and remove items from the map so we currently
+  // just make a new list and add all of the matching types to it, and
+  // then swap it into m_types at the end
   collection matching_types;
 
   iterator pos, end = m_types.end();
Index: source/Symbol/TypeMap.cpp
===================================================================
--- source/Symbol/TypeMap.cpp
+++ source/Symbol/TypeMap.cpp
@@ -45,7 +45,8 @@
 TypeMap::~TypeMap() {}
 
 void TypeMap::Insert(const TypeSP &type_sp) {
-  // Just push each type on the back for now. We will worry about uniquing later
+  // Just push each type on the back for now. We will worry about uniquing
+  // later
   if (type_sp)
     m_types.insert(std::make_pair(type_sp->GetID(), type_sp));
 }
@@ -99,9 +100,9 @@
 
 bool TypeMap::Empty() const { return m_types.empty(); }
 
-// GetTypeAtIndex isn't used a lot for large type lists, currently only for
-// type lists that are returned for "image dump -t TYPENAME" commands and other
-// simple symbol queries that grab the first result...
+// GetTypeAtIndex isn't used a lot for large type lists, currently only
+// for type lists that are returned for "image dump -t TYPENAME" commands
+// and other simple symbol queries that grab the first result...
 
 TypeSP TypeMap::GetTypeAtIndex(uint32_t idx) {
   iterator pos, end;
@@ -167,10 +168,10 @@
 void TypeMap::RemoveMismatchedTypes(const std::string &type_scope,
                                     const std::string &type_basename,
                                     TypeClass type_class, bool exact_match) {
-  // Our "collection" type currently is a std::map which doesn't
-  // have any good way to iterate and remove items from the map
-  // so we currently just make a new list and add all of the matching
-  // types to it, and then swap it into m_types at the end
+  // Our "collection" type currently is a std::map which doesn't have any
+  // good way to iterate and remove items from the map so we currently
+  // just make a new list and add all of the matching types to it, and
+  // then swap it into m_types at the end
   collection matching_types;
 
   iterator pos, end = m_types.end();
@@ -204,20 +205,17 @@
               const size_t type_scope_pos = match_type_scope.rfind(type_scope);
               if (type_scope_pos == match_type_scope_size - type_scope_size) {
                 if (type_scope_pos >= 2) {
-                  // Our match scope ends with the type scope we were looking
-                  // for,
-                  // but we need to make sure what comes before the matching
-                  // type scope is a namespace boundary in case we are trying to
+                  // Our match scope ends with the type scope we were
+                  // looking for, but we need to make sure what comes
+                  // before the matching type scope is a namespace
+                  // boundary in case we are trying to match:
+                  // type_basename = "d" type_scope = "b::c::" We want to
                   // match:
-                  // type_basename = "d"
-                  // type_scope = "b::c::"
-                  // We want to match:
                   //  match_type_scope "a::b::c::"
                   // But not:
                   //  match_type_scope "a::bb::c::"
                   // So below we make sure what comes before "b::c::" in
-                  // match_type_scope
-                  // is "::", or the namespace boundary
+                  // match_type_scope is "::", or the namespace boundary
                   if (match_type_scope[type_scope_pos - 1] == ':' &&
                       match_type_scope[type_scope_pos - 2] == ':') {
                     keep_match = true;
@@ -228,9 +226,9 @@
           }
         }
       } else {
-        // The type we are currently looking at doesn't exists
-        // in a namespace or class, so it only matches if there
-        // is no type scope...
+        // The type we are currently looking at doesn't exists in a
+        // namespace or class, so it only matches if there is no type
+        // scope...
         keep_match =
             type_scope.empty() && type_basename.compare(match_type_name) == 0;
       }
@@ -247,10 +245,10 @@
   if (type_class == eTypeClassAny)
     return;
 
-  // Our "collection" type currently is a std::map which doesn't
-  // have any good way to iterate and remove items from the map
-  // so we currently just make a new list and add all of the matching
-  // types to it, and then swap it into m_types at the end
+  // Our "collection" type currently is a std::map which doesn't have any
+  // good way to iterate and remove items from the map so we currently
+  // just make a new list and add all of the matching types to it, and
+  // then swap it into m_types at the end
   collection matching_types;
 
   iterator pos, end = m_types.end();
Index: source/Symbol/TypeSystem.cpp
===================================================================
--- source/Symbol/TypeSystem.cpp
+++ source/Symbol/TypeSystem.cpp
@@ -215,7 +215,8 @@
   if (!can_create)
     return nullptr;
 
-  // Cache even if we get a shared pointer that contains null type system back
+  // Cache even if we get a shared pointer that contains null type system
+  // back
   lldb::TypeSystemSP type_system_sp =
       TypeSystem::CreateInstance(language, module);
   AddToMap(language, type_system_sp);
@@ -243,7 +244,8 @@
   if (!can_create)
     return nullptr;
 
-  // Cache even if we get a shared pointer that contains null type system back
+  // Cache even if we get a shared pointer that contains null type system
+  // back
   lldb::TypeSystemSP type_system_sp;
   if (!m_clear_in_progress)
     type_system_sp = TypeSystem::CreateInstance(language, target);
Index: source/Symbol/UnwindPlan.cpp
===================================================================
--- source/Symbol/UnwindPlan.cpp
+++ source/Symbol/UnwindPlan.cpp
@@ -45,9 +45,8 @@
   return false;
 }
 
-// This function doesn't copy the dwarf expression bytes; they must remain in
-// allocated
-// memory for the lifespan of this UnwindPlan object.
+// This function doesn't copy the dwarf expression bytes; they must remain
+// in allocated memory for the lifespan of this UnwindPlan object.
 void UnwindPlan::Row::RegisterLocation::SetAtDWARFExpression(
     const uint8_t *opcodes, uint32_t len) {
   m_type = atDWARFExpression;
@@ -55,9 +54,8 @@
   m_location.expr.length = len;
 }
 
-// This function doesn't copy the dwarf expression bytes; they must remain in
-// allocated
-// memory for the lifespan of this UnwindPlan object.
+// This function doesn't copy the dwarf expression bytes; they must remain
+// in allocated memory for the lifespan of this UnwindPlan object.
 void UnwindPlan::Row::RegisterLocation::SetIsDWARFExpression(
     const uint8_t *opcodes, uint32_t len) {
   m_type = isDWARFExpression;
@@ -396,9 +394,9 @@
     return false;
   }
 
-  // If the 0th Row of unwind instructions is missing, or if it doesn't provide
-  // a register to use to find the Canonical Frame Address, this is not a valid
-  // UnwindPlan.
+  // If the 0th Row of unwind instructions is missing, or if it doesn't
+  // provide a register to use to find the Canonical Frame Address, this
+  // is not a valid UnwindPlan.
   if (GetRowAtIndex(0).get() == nullptr ||
       GetRowAtIndex(0)->GetCFAValue().GetValueType() ==
           Row::CFAValue::unspecified) {
Index: source/Symbol/UnwindTable.cpp
===================================================================
--- source/Symbol/UnwindTable.cpp
+++ source/Symbol/UnwindTable.cpp
@@ -20,10 +20,10 @@
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 
-// There is one UnwindTable object per ObjectFile.
-// It contains a list of Unwind objects -- one per function, populated lazily --
-// for the ObjectFile.
-// Each Unwind object has multiple UnwindPlans for different scenarios.
+// There is one UnwindTable object per ObjectFile. It contains a list of
+// Unwind objects -- one per function, populated lazily -- for the
+// ObjectFile. Each Unwind object has multiple UnwindPlans for different
+// scenarios.
 
 using namespace lldb;
 using namespace lldb_private;
@@ -32,9 +32,8 @@
     : m_object_file(objfile), m_unwinds(), m_initialized(false), m_mutex(),
       m_eh_frame_up(), m_compact_unwind_up(), m_arm_unwind_up() {}
 
-// We can't do some of this initialization when the ObjectFile is running its
-// ctor; delay doing it
-// until needed for something.
+// We can't do some of this initialization when the ObjectFile is running
+// its ctor; delay doing it until needed for something.
 
 void UnwindTable::Initialize() {
   if (m_initialized)
@@ -106,7 +105,8 @@
 
   std::lock_guard<std::mutex> guard(m_mutex);
 
-  // There is an UnwindTable per object file, so we can safely use file handles
+  // There is an UnwindTable per object file, so we can safely use file
+  // handles
   addr_t file_addr = addr.GetFileAddress();
   iterator end = m_unwinds.end();
   iterator insert_pos = end;
@@ -133,11 +133,10 @@
   return func_unwinder_sp;
 }
 
-// Ignore any existing FuncUnwinders for this function, create a new one and
-// don't add it to the
-// UnwindTable.  This is intended for use by target modules show-unwind where we
-// want to create
-// new UnwindPlans, not re-use existing ones.
+// Ignore any existing FuncUnwinders for this function, create a new one
+// and don't add it to the UnwindTable.  This is intended for use by
+// target modules show-unwind where we want to create new UnwindPlans, not
+// re-use existing ones.
 FuncUnwindersSP
 UnwindTable::GetUncachedFuncUnwindersContainingAddress(const Address &addr,
                                                        SymbolContext &sc) {
Index: source/Symbol/Variable.cpp
===================================================================
--- source/Symbol/Variable.cpp
+++ source/Symbol/Variable.cpp
@@ -239,9 +239,8 @@
               target_sp.get());
       if (loclist_base_load_addr == LLDB_INVALID_ADDRESS)
         return false;
-      // It is a location list. We just need to tell if the location
-      // list contains the current address when converted to a load
-      // address
+      // It is a location list. We just need to tell if the location list
+      // contains the current address when converted to a load address
       return m_location.LocationListContainsAddress(
           loclist_base_load_addr,
           frame->GetFrameCodeAddress().GetLoadAddress(target_sp.get()));
@@ -251,8 +250,8 @@
 }
 
 bool Variable::LocationIsValidForAddress(const Address &address) {
-  // Be sure to resolve the address to section offset prior to
-  // calling this function.
+  // Be sure to resolve the address to section offset prior to calling
+  // this function.
   if (address.IsSectionOffset()) {
     SymbolContext sc;
     CalculateSymbolContext(&sc);
@@ -312,9 +311,8 @@
             !variable_sc.block->Contains(deepest_frame_block))
           return false;
 
-        // If no scope range is specified then it means that the scope is the
-        // same as the
-        // scope of the enclosing lexical block.
+        // If no scope range is specified then it means that the scope is
+        // the same as the scope of the enclosing lexical block.
         if (m_scope_range.IsEmpty())
           return true;
 
@@ -455,8 +453,8 @@
 }
 
 bool Variable::DumpLocationForAddress(Stream *s, const Address &address) {
-  // Be sure to resolve the address to section offset prior to
-  // calling this function.
+  // Be sure to resolve the address to section offset prior to calling
+  // this function.
   if (address.IsSectionOffset()) {
     SymbolContext sc;
     CalculateSymbolContext(&sc);
Index: source/Target/ABI.cpp
===================================================================
--- source/Target/ABI.cpp
+++ source/Target/ABI.cpp
@@ -95,11 +95,10 @@
   if (!return_valobj_sp)
     return return_valobj_sp;
 
-  // Now turn this into a persistent variable.
-  // FIXME: This code is duplicated from Target::EvaluateExpression, and it is
-  // used in similar form in a couple
-  // of other places.  Figure out the correct Create function to do all this
-  // work.
+  // Now turn this into a persistent variable. FIXME: This code is
+  // duplicated from Target::EvaluateExpression, and it is used in similar
+  // form in a couple of other places.  Figure out the correct Create
+  // function to do all this work.
 
   if (persistent) {
     Target &target = *thread.CalculateTarget();
@@ -174,8 +173,8 @@
 
 // specialized to work with llvm IR types
 //
-// for now we will specify a default implementation so that we don't need to
-// modify other ABIs
+// for now we will specify a default implementation so that we don't need
+// to modify other ABIs
 lldb::ValueObjectSP ABI::GetReturnValueObjectImpl(Thread &thread,
                                                   llvm::Type &ir_type) const {
   ValueObjectSP return_valobj_sp;
@@ -196,18 +195,18 @@
 bool ABI::GetFallbackRegisterLocation(
     const RegisterInfo *reg_info,
     UnwindPlan::Row::RegisterLocation &unwind_regloc) {
-  // Did the UnwindPlan fail to give us the caller's stack pointer?
-  // The stack pointer is defined to be the same as THIS frame's CFA, so return
-  // the CFA value as
-  // the caller's stack pointer.  This is true on x86-32/x86-64 at least.
+  // Did the UnwindPlan fail to give us the caller's stack pointer? The
+  // stack pointer is defined to be the same as THIS frame's CFA, so
+  // return the CFA value as the caller's stack pointer.  This is true on
+  // x86-32/x86-64 at least.
   if (reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_SP) {
     unwind_regloc.SetIsCFAPlusOffset(0);
     return true;
   }
 
-  // If a volatile register is being requested, we don't want to forward the
-  // next frame's register contents
-  // up the stack -- the register is not retrievable at this frame.
+  // If a volatile register is being requested, we don't want to forward
+  // the next frame's register contents up the stack -- the register is
+  // not retrievable at this frame.
   if (RegisterIsVolatile(reg_info)) {
     unwind_regloc.SetUndefined();
     return true;
Index: source/Target/ExecutionContext.cpp
===================================================================
--- source/Target/ExecutionContext.cpp
+++ source/Target/ExecutionContext.cpp
@@ -368,10 +368,9 @@
 }
 
 bool ExecutionContext::operator==(const ExecutionContext &rhs) const {
-  // Check that the frame shared pointers match, or both are valid and their
-  // stack
-  // IDs match since sometimes we get new objects that represent the same
-  // frame within a thread.
+  // Check that the frame shared pointers match, or both are valid and
+  // their stack IDs match since sometimes we get new objects that
+  // represent the same frame within a thread.
   if ((m_frame_sp == rhs.m_frame_sp) ||
       (m_frame_sp && rhs.m_frame_sp &&
        m_frame_sp->GetStackID() == rhs.m_frame_sp->GetStackID())) {
@@ -525,8 +524,8 @@
           m_process_wp = process_sp;
           if (process_sp) {
             // Only fill in the thread and frame if our process is stopped
-            // Don't just check the state, since we might be in the middle of
-            // resuming.
+            // Don't just check the state, since we might be in the middle
+            // of resuming.
             Process::StopLocker stop_locker;
 
             if (stop_locker.TryLock(&process_sp->GetRunLock()) &&
@@ -597,8 +596,8 @@
 
   if (m_tid != LLDB_INVALID_THREAD_ID) {
     // We check if the thread has been destroyed in cases where clients
-    // might still have shared pointer to a thread, but the thread is
-    // not valid anymore (not part of the process)
+    // might still have shared pointer to a thread, but the thread is not
+    // valid anymore (not part of the process)
     if (!thread_sp || !thread_sp->IsValid()) {
       lldb::ProcessSP process_sp(GetProcessSP());
       if (process_sp && process_sp->IsValid()) {
@@ -608,9 +607,8 @@
     }
   }
 
-  // Check that we aren't about to return an invalid thread sp.  We might return
-  // a nullptr thread_sp,
-  // but don't return an invalid one.
+  // Check that we aren't about to return an invalid thread sp.  We might
+  // return a nullptr thread_sp, but don't return an invalid one.
 
   if (thread_sp && !thread_sp->IsValid())
     thread_sp.reset();
Index: source/Target/Language.cpp
===================================================================
--- source/Target/Language.cpp
+++ source/Target/Language.cpp
@@ -127,8 +127,8 @@
 };
 
 struct language_name_pair language_names[] = {
-    // To allow GetNameForLanguageType to be a simple array lookup, the first
-    // part of this array must follow enum LanguageType exactly.
+    // To allow GetNameForLanguageType to be a simple array lookup, the
+    // first part of this array must follow enum LanguageType exactly.
     {"unknown", eLanguageTypeUnknown},
     {"c89", eLanguageTypeC89},
     {"c", eLanguageTypeC},
Index: source/Target/LanguageRuntime.cpp
===================================================================
--- source/Target/LanguageRuntime.cpp
+++ source/Target/LanguageRuntime.cpp
@@ -101,8 +101,8 @@
   return result_sp;
 }
 
-// The Target is the one that knows how to create breakpoints, so this function
-// is meant to be used either by the target or internally in
+// The Target is the one that knows how to create breakpoints, so this
+// function is meant to be used either by the target or internally in
 // Set/ClearExceptionBreakpoints.
 class ExceptionBreakpointResolver : public BreakpointResolver {
 public:
@@ -286,10 +286,11 @@
       CommandObjectSP command =
           command_callback(parent->GetCommandInterpreter());
       if (command) {
-        // the CommandObject vended by a Language plugin cannot be created once
-        // and cached because we may create multiple debuggers and need one
-        // instance of the command each - the implementing function is meant to
-        // create a new instance of the command each time it is invoked.
+        // the CommandObject vended by a Language plugin cannot be created
+        // once and cached because we may create multiple debuggers and
+        // need one instance of the command each - the implementing
+        // function is meant to create a new instance of the command each
+        // time it is invoked.
         parent->LoadSubCommand(command->GetCommandName().str().c_str(), command);
       }
     }
Index: source/Target/Memory.cpp
===================================================================
--- source/Target/Memory.cpp
+++ source/Target/Memory.cpp
@@ -62,7 +62,8 @@
 
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
-  // Erase any blocks from the L1 cache that intersect with the flush range
+  // Erase any blocks from the L1 cache that intersect with the flush
+  // range
   if (!m_L1_cache.empty()) {
     AddrRange flush_range(addr, size);
     BlockMap::iterator pos = m_L1_cache.upper_bound(addr);
@@ -83,8 +84,8 @@
     const addr_t first_cache_line_addr = addr - (addr % cache_line_byte_size);
     const addr_t last_cache_line_addr =
         end_addr - (end_addr % cache_line_byte_size);
-    // Watch for overflow where size will cause us to go off the end of the
-    // 64 bit address space
+    // Watch for overflow where size will cause us to go off the end of
+    // the 64 bit address space
     uint32_t num_cache_lines;
     if (last_cache_line_addr >= first_cache_line_addr)
       num_cache_lines = ((last_cache_line_addr - first_cache_line_addr) /
@@ -135,10 +136,11 @@
 
   // Check the L1 cache for a range that contain the entire memory read.
   // If we find a range in the L1 cache that does, we use it. Else we fall
-  // back to reading memory in m_L2_cache_line_byte_size byte sized chunks.
-  // The L1 cache contains chunks of memory that are not required to be
-  // m_L2_cache_line_byte_size bytes in size, so we don't try anything
-  // tricky when reading from them (no partial reads from the L1 cache).
+  // back to reading memory in m_L2_cache_line_byte_size byte sized
+  // chunks. The L1 cache contains chunks of memory that are not required
+  // to be m_L2_cache_line_byte_size bytes in size, so we don't try
+  // anything tricky when reading from them (no partial reads from the L1
+  // cache).
 
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (!m_L1_cache.empty()) {
@@ -158,10 +160,10 @@
   // If this memory read request is larger than the cache line size, then
   // we (1) try to read as much of it at once as possible, and (2) don't
   // add the data to the memory cache.  We don't want to split a big read
-  // up into more separate reads than necessary, and with a large memory read
-  // request, it is unlikely that the caller function will ask for the next
-  // 4 bytes after the large memory read - so there's little benefit to saving
-  // it in the cache.
+  // up into more separate reads than necessary, and with a large memory
+  // read request, it is unlikely that the caller function will ask for
+  // the next 4 bytes after the large memory read - so there's little
+  // benefit to saving it in the cache.
   if (dst && dst_len > m_L2_cache_line_byte_size) {
     size_t bytes_read =
         m_process.ReadMemoryFromInferior(addr, dst, dst_len, error);
@@ -218,9 +220,9 @@
             bytes_left -= curr_read_size;
             curr_addr += curr_read_size;
 
-            // We have a cache page that succeeded to read some bytes
-            // but not an entire page. If this happens, we must cap
-            // off how much data we are able to read...
+            // We have a cache page that succeeded to read some bytes but
+            // not an entire page. If this happens, we must cap off how
+            // much data we are able to read...
             if (pos->second->GetByteSize() != cache_line_byte_size)
               return dst_len - bytes_left;
           }
@@ -242,8 +244,8 @@
         if (process_bytes_read != cache_line_byte_size)
           data_buffer_heap_ap->SetByteSize(process_bytes_read);
         m_L2_cache[curr_addr] = DataBufferSP(data_buffer_heap_ap.release());
-        // We have read data and put it into the cache, continue through the
-        // loop again to get the data out of the cache...
+        // We have read data and put it into the cache, continue through
+        // the loop again to get the data out of the cache...
       }
     }
   }
@@ -276,9 +278,9 @@
     const lldb::addr_t range_size = free_block.GetByteSize();
     if (range_size >= size)
     {
-      // We found a free block that is big enough for our data. Figure out how
-      // many chunks we will need and calculate the resulting block size we will
-      // reserve.
+      // We found a free block that is big enough for our data. Figure out
+      // how many chunks we will need and calculate the resulting block
+      // size we will reserve.
       addr_t addr = free_block.GetRangeBase();
       size_t num_chunks = CalculateChunksNeededForSize(size);
       lldb::addr_t block_size = num_chunks * m_chunk_size;
@@ -286,18 +288,19 @@
       if (bytes_left == 0)
       {
         // The newly allocated block will take all of the bytes in this
-        // available block, so we can just add it to the allocated ranges and
-        // remove the range from the free ranges.
+        // available block, so we can just add it to the allocated ranges
+        // and remove the range from the free ranges.
         m_reserved_blocks.Insert(free_block, false);
         m_free_blocks.RemoveEntryAtIndex(i);
       }
       else
       {
-        // Make the new allocated range and add it to the allocated ranges.
+        // Make the new allocated range and add it to the allocated
+        // ranges.
         Range<lldb::addr_t, uint32_t> reserved_block(free_block);
         reserved_block.SetByteSize(block_size);
-        // Insert the reserved range and don't combine it with other blocks
-        // in the reserved blocks list.
+        // Insert the reserved range and don't combine it with other
+        // blocks in the reserved blocks list.
         m_reserved_blocks.Insert(reserved_block, false);
         // Adjust the free range in place since we won't change the sorted
         // ordering of the m_free_blocks list.
Index: source/Target/ModuleCache.cpp
===================================================================
--- source/Target/ModuleCache.cpp
+++ source/Target/ModuleCache.cpp
@@ -231,8 +231,8 @@
     return Status("Module %s has invalid file size",
                   module_file_path.GetPath().c_str());
 
-  // We may have already cached module but downloaded from an another host - in
-  // this case let's create a link to it.
+  // We may have already cached module but downloaded from an another host
+  // - in this case let's create a link to it.
   auto error = CreateHostSysRootModuleLink(root_dir_spec, hostname,
                                            module_spec.GetFileSpec(),
                                            module_file_path, false);
@@ -311,10 +311,9 @@
   error = symfile_downloader(cached_module_sp, tmp_download_sym_file_spec);
   llvm::FileRemover tmp_symfile_remover(tmp_download_sym_file_spec.GetPath());
   if (error.Fail())
-    // Failed to download a symfile but fetching the module was successful. The
-    // module might
-    // contain the necessary symbols and the debugging is also possible without
-    // a symfile.
+    // Failed to download a symfile but fetching the module was
+    // successful. The module might contain the necessary symbols and the
+    // debugging is also possible without a symfile.
     return Status();
 
   error = Put(root_dir_spec, escaped_hostname.c_str(), module_spec,
Index: source/Target/ObjCLanguageRuntime.cpp
===================================================================
--- source/Target/ObjCLanguageRuntime.cpp
+++ source/Target/ObjCLanguageRuntime.cpp
@@ -169,17 +169,16 @@
   if (name) {
     UpdateISAToDescriptorMap();
     if (m_hash_to_isa_map.empty()) {
-      // No name hashes were provided, we need to just linearly power through
-      // the
-      // names and find a match
+      // No name hashes were provided, we need to just linearly power
+      // through the names and find a match
       for (ISAToDescriptorIterator pos = m_isa_to_descriptor.begin();
            pos != end; ++pos) {
         if (pos->second->GetClassName() == name)
           return pos;
       }
     } else {
-      // Name hashes were provided, so use them to efficiently lookup name to
-      // isa/descriptor
+      // Name hashes were provided, so use them to efficiently lookup name
+      // to isa/descriptor
       const uint32_t name_hash = llvm::djbHash(name.GetStringRef());
       std::pair<HashToISAIterator, HashToISAIterator> range =
           m_hash_to_isa_map.equal_range(name_hash);
Index: source/Target/PathMappingList.cpp
===================================================================
--- source/Target/PathMappingList.cpp
+++ source/Target/PathMappingList.cpp
@@ -106,8 +106,8 @@
   return true;
 }
 
-// For clients which do not need the pair index dumped, pass a pair_index >= 0
-// to only dump the indicated pair.
+// For clients which do not need the pair index dumped, pass a pair_index
+// >= 0 to only dump the indicated pair.
 void PathMappingList::Dump(Stream *s, int pair_index) {
   unsigned int numPairs = m_pairs.size();
 
@@ -178,7 +178,8 @@
     return false;
 
   for (const auto &it : m_pairs) {
-    // FIXME: This should be using FileSpec API's to do the path appending.
+    // FIXME: This should be using FileSpec API's to do the path
+    // appending.
     const size_t prefixLen = it.second.GetLength();
     if (::strncmp(it.second.GetCString(), path_cstr, prefixLen) == 0) {
       std::string new_path_str(it.first.GetCString());
Index: source/Target/Platform.cpp
===================================================================
--- source/Target/Platform.cpp
+++ source/Target/Platform.cpp
@@ -309,7 +309,8 @@
           return platform_sp;
       }
 
-      // Next try compatible arch matches across all platforms already created
+      // Next try compatible arch matches across all platforms already
+      // created
       for (const auto &platform_sp : GetPlatformList()) {
         if (platform_sp->IsCompatibleArchitecture(arch, false,
                                                   platform_arch_ptr))
@@ -460,18 +461,17 @@
       m_os_version_set_while_connected = success;
     }
   } else {
-    // We have a remote platform. We can only fetch the remote
-    // OS version if we are connected, and we don't want to do it
-    // more than once.
+    // We have a remote platform. We can only fetch the remote OS version
+    // if we are connected, and we don't want to do it more than once.
 
     const bool is_connected = IsConnected();
 
     bool fetch = false;
     if (success) {
       // We have valid OS version info, check to make sure it wasn't
-      // manually set prior to connecting. If it was manually set prior
-      // to connecting, then lets fetch the actual OS version info
-      // if we are now connected.
+      // manually set prior to connecting. If it was manually set prior to
+      // connecting, then lets fetch the actual OS version info if we are
+      // now connected.
       if (is_connected && !m_os_version_set_while_connected)
         fetch = true;
     } else {
@@ -490,8 +490,8 @@
     minor = m_minor_os_version;
     update = m_update_os_version;
   } else if (process) {
-    // Check with the process in case it can answer the question if
-    // a process was provided
+    // Check with the process in case it can answer the question if a
+    // process was provided
     return process->GetHostOSVersion(major, minor, update);
   }
   return success;
@@ -579,7 +579,8 @@
     std::string src_dir_path(src.GetPath());
 
     // Make a filespec that only fills in the directory of a FileSpec so
-    // when we enumerate we can quickly fill in the filename for dst copies
+    // when we enumerate we can quickly fill in the filename for dst
+    // copies
     FileSpec recurse_dst;
     recurse_dst.GetDirectory().SetCString(dst_dir.GetPath().c_str());
     RecurseCopyBaton rc_baton2 = {recurse_dst, rc_baton->platform_ptr,
@@ -657,9 +658,9 @@
       if (first_dst_dir_char == '/' || first_dst_dir_char == '\\') {
         fixed_dst.GetDirectory() = dst.GetDirectory();
       }
-      // If the fixed destination file doesn't have a directory yet,
-      // then we must have a relative path. We will resolve this relative
-      // path against the platform's working directory
+      // If the fixed destination file doesn't have a directory yet, then
+      // we must have a relative path. We will resolve this relative path
+      // against the platform's working directory
       if (!fixed_dst.GetDirectory()) {
         FileSpec relative_spec;
         std::string path;
@@ -711,8 +712,9 @@
         permissions = eFilePermissionsDirectoryDefault;
       error = MakeDirectory(fixed_dst, permissions);
       if (error.Success()) {
-        // Make a filespec that only fills in the directory of a FileSpec so
-        // when we enumerate we can quickly fill in the filename for dst copies
+        // Make a filespec that only fills in the directory of a FileSpec
+        // so when we enumerate we can quickly fill in the filename for
+        // dst copies
         FileSpec recurse_dst;
         recurse_dst.GetDirectory().SetCString(fixed_dst.GetCString());
         std::string src_dir_path(src.GetPath());
@@ -868,15 +870,15 @@
     return false;
   } else {
     // We have a remote platform, allow setting the target OS version if
-    // we aren't connected, since if we are connected, we should be able to
-    // request the remote OS version from the connected platform.
+    // we aren't connected, since if we are connected, we should be able
+    // to request the remote OS version from the connected platform.
     if (IsConnected())
       return false;
     else {
-      // We aren't connected and we might want to set the OS version
-      // ahead of time before we connect so we can peruse files and
-      // use a local SDK or PDK cache of support files to disassemble
-      // or do other things.
+      // We aren't connected and we might want to set the OS version ahead
+      // of time before we connect so we can peruse files and use a local
+      // SDK or PDK cache of support files to disassemble or do other
+      // things.
       m_major_os_version = major;
       m_minor_os_version = minor;
       m_update_os_version = update;
@@ -897,9 +899,9 @@
                                           module_search_paths_ptr, nullptr,
                                           nullptr);
     } else {
-      // No valid architecture was specified, ask the platform for
-      // the architectures that we should be using (in the correct order)
-      // and see if we can find a match that way
+      // No valid architecture was specified, ask the platform for the
+      // architectures that we should be using (in the correct order) and
+      // see if we can find a match that way
       ModuleSpec arch_module_spec(module_spec);
       for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
                idx, arch_module_spec.GetArchitecture());
@@ -943,18 +945,18 @@
       m_system_arch_set_while_connected = m_system_arch.IsValid();
     }
   } else {
-    // We have a remote platform. We can only fetch the remote
-    // system architecture if we are connected, and we don't want to do it
-    // more than once.
+    // We have a remote platform. We can only fetch the remote system
+    // architecture if we are connected, and we don't want to do it more
+    // than once.
 
     const bool is_connected = IsConnected();
 
     bool fetch = false;
     if (m_system_arch.IsValid()) {
       // We have valid OS version info, check to make sure it wasn't
-      // manually set prior to connecting. If it was manually set prior
-      // to connecting, then lets fetch the actual OS version info
-      // if we are now connected.
+      // manually set prior to connecting. If it was manually set prior to
+      // connecting, then lets fetch the actual OS version info if we are
+      // now connected.
       if (is_connected && !m_system_arch_set_while_connected)
         fetch = true;
     } else {
@@ -1026,8 +1028,8 @@
 
 bool Platform::GetProcessInfo(lldb::pid_t pid,
                               ProcessInstanceInfo &process_info) {
-  // Take care of the host case so that each subclass can just
-  // call this function to get the host functionality.
+  // Take care of the host case so that each subclass can just call this
+  // function to get the host functionality.
   if (IsHost())
     return Host::GetProcessInfo(pid, process_info);
   return false;
@@ -1035,8 +1037,8 @@
 
 uint32_t Platform::FindProcesses(const ProcessInstanceInfoMatch &match_info,
                                  ProcessInstanceInfoList &process_infos) {
-  // Take care of the host case so that each subclass can just
-  // call this function to get the host functionality.
+  // Take care of the host case so that each subclass can just call this
+  // function to get the host functionality.
   uint32_t match_count = 0;
   if (IsHost())
     match_count = Host::FindProcesses(match_info, process_infos);
@@ -1049,8 +1051,8 @@
   if (log)
     log->Printf("Platform::%s()", __FUNCTION__);
 
-  // Take care of the host case so that each subclass can just
-  // call this function to get the host functionality.
+  // Take care of the host case so that each subclass can just call this
+  // function to get the host functionality.
   if (IsHost()) {
     if (::getenv("LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY"))
       launch_info.GetFlags().Set(eLaunchFlagLaunchInTTY);
@@ -1106,9 +1108,8 @@
   if (log)
     log->Printf("Platform::%s, pid %" PRIu64, __FUNCTION__, pid);
 
-  // Try to find a process plugin to handle this Kill request.  If we can't,
-  // fall back to
-  // the default OS implementation.
+  // Try to find a process plugin to handle this Kill request.  If we
+  // can't, fall back to the default OS implementation.
   size_t num_debuggers = Debugger::GetNumDebuggers();
   for (size_t didx = 0; didx < num_debuggers; ++didx) {
     DebuggerSP debugger = Debugger::GetDebuggerAtIndex(didx);
@@ -1142,17 +1143,17 @@
   ProcessSP process_sp;
   // Make sure we stop at the entry point
   launch_info.GetFlags().Set(eLaunchFlagDebug);
-  // We always launch the process we are going to debug in a separate process
-  // group, since then we can handle ^C interrupts ourselves w/o having to worry
-  // about the target getting them as well.
+  // We always launch the process we are going to debug in a separate
+  // process group, since then we can handle ^C interrupts ourselves w/o
+  // having to worry about the target getting them as well.
   launch_info.SetLaunchInSeparateProcessGroup(true);
 
-  // Allow any StructuredData process-bound plugins to adjust the launch info
-  // if needed
+  // Allow any StructuredData process-bound plugins to adjust the launch
+  // info if needed
   size_t i = 0;
   bool iteration_complete = false;
-  // Note iteration can't simply go until a nullptr callback is returned, as
-  // it is valid for a plugin to not supply a filter.
+  // Note iteration can't simply go until a nullptr callback is returned,
+  // as it is valid for a plugin to not supply a filter.
   auto get_filter_func = PluginManager::GetStructuredDataFilterCallbackAtIndex;
   for (auto filter_callback = get_filter_func(i, iteration_complete);
        !iteration_complete;
@@ -1186,10 +1187,10 @@
                       __FUNCTION__, process_sp->GetPluginName().AsCString());
         launch_info.SetHijackListener(attach_info.GetHijackListener());
 
-        // Since we attached to the process, it will think it needs to detach
-        // if the process object just goes away without an explicit call to
-        // Process::Kill() or Process::Detach(), so let it know to kill the
-        // process if this happens.
+        // Since we attached to the process, it will think it needs to
+        // detach if the process object just goes away without an explicit
+        // call to Process::Kill() or Process::Detach(), so let it know to
+        // kill the process if this happens.
         process_sp->SetShouldDetach(false);
 
         // If we didn't have any file actions, the pseudo terminal might
@@ -1314,8 +1315,8 @@
 
     offset += bytes_written;
     if (bytes_written != bytes_read) {
-      // We didn't write the correct number of bytes, so adjust
-      // the file position in the source file we are reading from...
+      // We didn't write the correct number of bytes, so adjust the file
+      // position in the source file we are reading from...
       source_file.SeekFromStart(offset);
     }
   }
@@ -1600,9 +1601,9 @@
 
   if (module_spec.GetArchitecture().IsValid() == false) {
     Status error;
-    // No valid architecture was specified, ask the platform for
-    // the architectures that we should be using (in the correct order)
-    // and see if we can find a match that way
+    // No valid architecture was specified, ask the platform for the
+    // architectures that we should be using (in the correct order) and
+    // see if we can find a match that way
     ModuleSpec arch_module_spec(module_spec);
     for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
              idx, arch_module_spec.GetArchitecture());
@@ -1628,8 +1629,8 @@
     }
   }
 
-  // If we are looking for a specific UUID, make sure resolved_module_spec has
-  // the same one before we search.
+  // If we are looking for a specific UUID, make sure resolved_module_spec
+  // has the same one before we search.
   if (module_spec.GetUUID().IsValid()) {
     resolved_module_spec.GetUUID() = module_spec.GetUUID();
   }
@@ -1756,8 +1757,8 @@
                              const lldb_private::FileSpec &remote_file,
                              lldb_private::Status &error) {
   if (local_file && remote_file) {
-    // Both local and remote file was specified. Install the local file to the
-    // given location.
+    // Both local and remote file was specified. Install the local file to
+    // the given location.
     if (IsRemote() || local_file != remote_file) {
       error = Install(local_file, remote_file);
       if (error.Fail())
@@ -1853,8 +1854,8 @@
 
   // TODO: support big-endian arm and thumb trap codes.
   case llvm::Triple::arm: {
-    // The ARM reference recommends the use of 0xe7fddefe and 0xdefe
-    // but the linux kernel does otherwise.
+    // The ARM reference recommends the use of 0xe7fddefe and 0xdefe but
+    // the linux kernel does otherwise.
     static const uint8_t g_arm_breakpoint_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
     static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};
 
Index: source/Target/Process.cpp
===================================================================
--- source/Target/Process.cpp
+++ source/Target/Process.cpp
@@ -75,8 +75,8 @@
 using namespace lldb_private;
 using namespace std::chrono;
 
-// Comment out line below to disable memory caching, overriding the process
-// setting target.process.disable-memory-cache
+// Comment out line below to disable memory caching, overriding the
+// process setting target.process.disable-memory-cache
 #define ENABLE_MEMORY_CACHING
 
 #ifdef ENABLE_MEMORY_CACHING
@@ -90,19 +90,18 @@
   ProcessOptionValueProperties(const ConstString &name)
       : OptionValueProperties(name) {}
 
-  // This constructor is used when creating ProcessOptionValueProperties when it
-  // is part of a new lldb_private::Process instance. It will copy all current
-  // global property values as needed
+  // This constructor is used when creating ProcessOptionValueProperties
+  // when it is part of a new lldb_private::Process instance. It will copy
+  // all current global property values as needed
   ProcessOptionValueProperties(ProcessProperties *global_properties)
       : OptionValueProperties(*global_properties->GetValueProperties()) {}
 
   const Property *GetPropertyAtIndex(const ExecutionContext *exe_ctx,
                                      bool will_modify,
                                      uint32_t idx) const override {
-    // When getting the value for a key from the process options, we will always
-    // try and grab the setting from the current process if there is one. Else
-    // we just
-    // use the one from this instance.
+    // When getting the value for a key from the process options, we will
+    // always try and grab the setting from the current process if there
+    // is one. Else we just use the one from this instance.
     if (exe_ctx) {
       Process *process = exe_ctx->GetProcessPtr();
       if (process) {
@@ -809,14 +808,14 @@
   StopPrivateStateThread();
 
   // ThreadList::Clear() will try to acquire this process's mutex, so
-  // explicitly clear the thread list here to ensure that the mutex
-  // is not destroyed before the thread list.
+  // explicitly clear the thread list here to ensure that the mutex is not
+  // destroyed before the thread list.
   m_thread_list.Clear();
 }
 
 const ProcessPropertiesSP &Process::GetGlobalProperties() {
-  // NOTE: intentional leak so we don't crash if global destructor chain gets
-  // called as other threads still use the result of this function
+  // NOTE: intentional leak so we don't crash if global destructor chain
+  // gets called as other threads still use the result of this function
   static ProcessPropertiesSP *g_settings_sp_ptr =
       new ProcessPropertiesSP(new ProcessProperties(nullptr));
   return *g_settings_sp_ptr;
@@ -848,13 +847,12 @@
   // Clear our broadcaster before we proceed with destroying
   Broadcaster::Clear();
 
-  // Do any cleanup needed prior to being destructed... Subclasses
-  // that override this method should call this superclass method as well.
+  // Do any cleanup needed prior to being destructed... Subclasses that
+  // override this method should call this superclass method as well.
 
   // We need to destroy the loader before the derived Process class gets
-  // destroyed
-  // since it is very likely that undoing the loader will require access to the
-  // real process.
+  // destroyed since it is very likely that undoing the loader will
+  // require access to the real process.
   m_dynamic_checkers_ap.reset();
   m_abi_sp.reset();
   m_os_ap.reset();
@@ -874,8 +872,8 @@
   m_language_runtimes.clear();
   m_instrumentation_runtimes.clear();
   m_next_event_action_ap.reset();
-  // Clear the last natural stop ID since it has a strong
-  // reference to this process
+  // Clear the last natural stop ID since it has a strong reference to
+  // this process
   m_mod_id.SetStopEventForLastNaturalStopID(EventSP());
   //#ifdef LLDB_CONFIGURATION_DEBUG
   //    StreamFile s(stdout, false);
@@ -928,17 +926,13 @@
   }
 }
 
-// FIXME: We need to do some work on events before the general Listener sees
-// them.
-// For instance if we are continuing from a breakpoint, we need to ensure that
-// we do
-// the little "insert real insn, step & stop" trick.  But we can't do that when
-// the
-// event is delivered by the broadcaster - since that is done on the thread that
-// is
-// waiting for new events, so if we needed more than one event for our handling,
-// we would
-// stall.  So instead we do it when we fetch the event off of the queue.
+// FIXME: We need to do some work on events before the general Listener
+// sees them. For instance if we are continuing from a breakpoint, we need
+// to ensure that we do the little "insert real insn, step & stop" trick.
+// But we can't do that when the event is delivered by the broadcaster -
+// since that is done on the thread that is waiting for new events, so if
+// we needed more than one event for our handling, we would stall.  So
+// instead we do it when we fetch the event off of the queue.
 //
 
 StateType Process::GetNextEvent(EventSP &event_sp) {
@@ -953,8 +947,8 @@
 }
 
 void Process::SyncIOHandler(uint32_t iohandler_id, uint64_t timeout_msec) {
-  // don't sync (potentially context switch) in case where there is no process
-  // IO
+  // don't sync (potentially context switch) in case where there is no
+  // process IO
   if (!m_process_input_reader)
     return;
 
@@ -973,16 +967,15 @@
                                         EventSP *event_sp_ptr, bool wait_always,
                                         ListenerSP hijack_listener_sp,
                                         Stream *stream, bool use_run_lock) {
-  // We can't just wait for a "stopped" event, because the stopped event may
-  // have restarted the target.
-  // We have to actually check each event, and in the case of a stopped event
-  // check the restarted flag
-  // on the event.
+  // We can't just wait for a "stopped" event, because the stopped event
+  // may have restarted the target. We have to actually check each event,
+  // and in the case of a stopped event check the restarted flag on the
+  // event.
   if (event_sp_ptr)
     event_sp_ptr->reset();
   StateType state = GetState();
-  // If we are exited or detached, we won't ever get back to any
-  // other valid state...
+  // If we are exited or detached, we won't ever get back to any other
+  // valid state...
   if (state == eStateDetached || state == eStateExited)
     return state;
 
@@ -1090,8 +1083,8 @@
         size_t num_reasons =
             Process::ProcessEventData::GetNumRestartedReasons(event_sp.get());
         if (num_reasons > 0) {
-          // FIXME: Do we want to report this, or would that just be annoyingly
-          // chatty?
+          // FIXME: Do we want to report this, or would that just be
+          // annoyingly chatty?
           if (num_reasons == 1) {
             const char *reason =
                 Process::ProcessEventData::GetRestartedReasonAtIndex(
@@ -1115,8 +1108,8 @@
       }
     } else {
       StopInfoSP curr_thread_stop_info_sp;
-      // Lock the thread list so it doesn't change on us, this is the scope for
-      // the locker:
+      // Lock the thread list so it doesn't change on us, this is the
+      // scope for the locker:
       {
         ThreadList &thread_list = process_sp->GetThreadList();
         std::lock_guard<std::recursive_mutex> guard(thread_list.GetMutex());
@@ -1147,11 +1140,10 @@
               break;
 
             case eStopReasonSignal: {
-              // Don't select a signal thread if we weren't going to stop at
-              // that
-              // signal.  We have to have had another reason for stopping here,
-              // and
-              // the user doesn't want to see this thread.
+              // Don't select a signal thread if we weren't going to stop
+              // at that signal.  We have to have had another reason for
+              // stopping here, and the user doesn't want to see this
+              // thread.
               uint64_t signo = thread->GetStopInfo()->GetValue();
               if (process_sp->GetUnixSignals()->GetShouldStop(signo)) {
                 if (!other_thread)
@@ -1190,11 +1182,10 @@
           }
         }
       }
-      // Drop the ThreadList mutex by here, since GetThreadStatus below might
-      // have to run code,
-      // e.g. for Data formatters, and if we hold the ThreadList mutex, then the
-      // process is going to
-      // have a hard time restarting the process.
+      // Drop the ThreadList mutex by here, since GetThreadStatus below
+      // might have to run code, e.g. for Data formatters, and if we hold
+      // the ThreadList mutex, then the process is going to have a hard
+      // time restarting the process.
       if (stream) {
         Debugger &debugger = process_sp->GetTarget().GetDebugger();
         if (debugger.GetTargetList().GetSelectedTarget().get() ==
@@ -1382,8 +1373,8 @@
   else
     m_exit_string.clear();
 
-  // Clear the last natural stop ID since it has a strong
-  // reference to this process
+  // Clear the last natural stop ID since it has a strong reference to
+  // this process
   m_mod_id.SetStopEventForLastNaturalStopID(EventSP());
 
   SetPrivateState(eStateExited);
@@ -1411,8 +1402,8 @@
 }
 
 // This static callback can be used to watch for local child processes on
-// the current host. The child process exits, the process will be
-// found in the global target list (we want to be completely sure that the
+// the current host. The child process exits, the process will be found in
+// the global target list (we want to be completely sure that the
 // lldb_private::Process doesn't go away before we can deliver the signal.
 bool Process::SetProcessExitStatus(
     lldb::pid_t pid, bool exited,
@@ -1449,35 +1440,33 @@
     const StateType state = GetPrivateState();
     if (StateIsStoppedState(state, true)) {
       std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
-      // m_thread_list does have its own mutex, but we need to
-      // hold onto the mutex between the call to UpdateThreadList(...)
-      // and the os->UpdateThreadList(...) so it doesn't change on us
+      // m_thread_list does have its own mutex, but we need to hold onto
+      // the mutex between the call to UpdateThreadList(...) and the
+      // os->UpdateThreadList(...) so it doesn't change on us
       ThreadList &old_thread_list = m_thread_list;
       ThreadList real_thread_list(this);
       ThreadList new_thread_list(this);
-      // Always update the thread list with the protocol specific
-      // thread list, but only update if "true" is returned
+      // Always update the thread list with the protocol specific thread
+      // list, but only update if "true" is returned
       if (UpdateThreadList(m_thread_list_real, real_thread_list)) {
-        // Don't call into the OperatingSystem to update the thread list if we
-        // are shutting down, since
-        // that may call back into the SBAPI's, requiring the API lock which is
-        // already held by whoever is
-        // shutting us down, causing a deadlock.
+        // Don't call into the OperatingSystem to update the thread list
+        // if we are shutting down, since that may call back into the
+        // SBAPI's, requiring the API lock which is already held by
+        // whoever is shutting us down, causing a deadlock.
         OperatingSystem *os = GetOperatingSystem();
         if (os && !m_destroy_in_process) {
-          // Clear any old backing threads where memory threads might have been
-          // backed by actual threads from the lldb_private::Process subclass
+          // Clear any old backing threads where memory threads might have
+          // been backed by actual threads from the lldb_private::Process
+          // subclass
           size_t num_old_threads = old_thread_list.GetSize(false);
           for (size_t i = 0; i < num_old_threads; ++i)
             old_thread_list.GetThreadAtIndex(i, false)->ClearBackingThread();
 
-          // Turn off dynamic types to ensure we don't run any expressions.
-          // Objective C
-          // can run an expression to determine if a SBValue is a dynamic type
-          // or not
-          // and we need to avoid this. OperatingSystem plug-ins can't run
-          // expressions
-          // that require running code...
+          // Turn off dynamic types to ensure we don't run any
+          // expressions. Objective C can run an expression to determine
+          // if a SBValue is a dynamic type or not and we need to avoid
+          // this. OperatingSystem plug-ins can't run expressions that
+          // require running code...
 
           Target &target = GetTarget();
           const lldb::DynamicValueType saved_prefer_dynamic =
@@ -1498,8 +1487,8 @@
           if (saved_prefer_dynamic != lldb::eNoDynamicValues)
             target.SetPreferDynamicValue(saved_prefer_dynamic);
         } else {
-          // No OS plug-in, the new thread list is the same as the real thread
-          // list
+          // No OS plug-in, the new thread list is the same as the real
+          // thread list
           new_thread_list = real_thread_list;
         }
 
@@ -1508,7 +1497,8 @@
         m_thread_list.SetStopID(stop_id);
 
         if (GetLastNaturalStopID() != m_extended_thread_stop_id) {
-          // Clear any extended threads that we may have accumulated previously
+          // Clear any extended threads that we may have accumulated
+          // previously
           m_extended_thread_list.Clear();
           m_extended_thread_stop_id = GetLastNaturalStopID();
 
@@ -1586,9 +1576,9 @@
   const StateType old_state = m_public_state.GetValue();
   m_public_state.SetValue(new_state);
 
-  // On the transition from Run to Stopped, we unlock the writer end of the
-  // run lock.  The lock gets locked in Resume, which is the public API
-  // to tell the program to run.
+  // On the transition from Run to Stopped, we unlock the writer end of
+  // the run lock.  The lock gets locked in Resume, which is the public
+  // API to tell the program to run.
   if (!StateChangedIsExternallyHijacked()) {
     if (new_state == eStateDetached) {
       if (log)
@@ -1701,17 +1691,17 @@
         new Event(eBroadcastBitStateChanged,
                   new ProcessEventData(shared_from_this(), new_state)));
     if (StateIsStoppedState(new_state, false)) {
-      // Note, this currently assumes that all threads in the list
-      // stop when the process stops.  In the future we will want to
-      // support a debugging model where some threads continue to run
-      // while others are stopped.  When that happens we will either need
-      // a way for the thread list to identify which threads are stopping
-      // or create a special thread list containing only threads which
-      // actually stopped.
+      // Note, this currently assumes that all threads in the list stop
+      // when the process stops.  In the future we will want to support a
+      // debugging model where some threads continue to run while others
+      // are stopped.  When that happens we will either need a way for the
+      // thread list to identify which threads are stopping or create a
+      // special thread list containing only threads which actually
+      // stopped.
       //
       // The process plugin is responsible for managing the actual
-      // behavior of the threads and should have stopped any threads
-      // that are going to stop before we get here.
+      // behavior of the threads and should have stopped any threads that
+      // are going to stop before we get here.
       m_thread_list.DidStop();
 
       m_mod_id.BumpStopID();
@@ -1914,9 +1904,8 @@
   if (load_addr != LLDB_INVALID_ADDRESS) {
     BreakpointSiteSP bp_site_sp;
 
-    // Look up this breakpoint site.  If it exists, then add this new owner,
-    // otherwise
-    // create a new breakpoint site and add it.
+    // Look up this breakpoint site.  If it exists, then add this new
+    // owner, otherwise create a new breakpoint site and add it.
 
     bp_site_sp = m_breakpoint_site_list.FindByAddress(load_addr);
 
@@ -1954,7 +1943,8 @@
                                             BreakpointSiteSP &bp_site_sp) {
   uint32_t num_owners = bp_site_sp->RemoveOwner(owner_id, owner_loc_id);
   if (num_owners == 0) {
-    // Don't try to disable the site if we don't have a live process anymore.
+    // Don't try to disable the site if we don't have a live process
+    // anymore.
     if (IsAlive())
       DisableBreakpointSite(bp_site_sp.get());
     m_breakpoint_site_list.RemoveByAddress(bp_site_sp->GetLoadAddress());
@@ -2020,8 +2010,8 @@
     error.SetErrorString("BreakpointSite contains an invalid load address.");
     return error;
   }
-  // Ask the lldb::Process subclass to fill in the correct software breakpoint
-  // trap for the breakpoint site
+  // Ask the lldb::Process subclass to fill in the correct software
+  // breakpoint trap for the breakpoint site
   const size_t bp_opcode_size = GetSoftwareBreakpointTrapOpcode(bp_site);
 
   if (bp_opcode_size == 0) {
@@ -2103,8 +2093,8 @@
         // Make sure the breakpoint opcode exists at this address
         if (::memcmp(curr_break_op, break_op, break_op_size) == 0) {
           break_op_found = true;
-          // We found a valid breakpoint opcode at this address, now restore
-          // the saved opcode.
+          // We found a valid breakpoint opcode at this address, now
+          // restore the saved opcode.
           if (DoWriteMemory(bp_addr, bp_site->GetSavedOpcodeBytes(),
                             break_op_size, error) == break_op_size) {
             verify = true;
@@ -2114,8 +2104,8 @@
         } else {
           error.SetErrorString(
               "Original breakpoint trap is no longer in memory.");
-          // Set verify to true and so we can check if the original opcode has
-          // already been restored
+          // Set verify to true and so we can check if the original opcode
+          // has already been restored
           verify = true;
         }
 
@@ -2164,7 +2154,8 @@
   return error;
 }
 
-// Uncomment to verify memory caching works after making changes to caching code
+// Uncomment to verify memory caching works after making changes to
+// caching code
 //#define VERIFY_MEMORY_READS
 
 size_t Process::ReadMemory(addr_t addr, void *buf, size_t size, Status &error) {
@@ -2179,9 +2170,9 @@
       // pretty confident this is working well. If any changes are made to
       // memory caching, uncomment the line below and test your changes!
 
-      // Verify all memory reads by using the cache first, then redundantly
-      // reading the same memory from the inferior and comparing to make sure
-      // everything is exactly the same.
+      // Verify all memory reads by using the cache first, then
+      // redundantly reading the same memory from the inferior and
+      // comparing to make sure everything is exactly the same.
       std::string verify_buf(size, '\0');
       assert(verify_buf.size() == size);
       const size_t cache_bytes_read =
@@ -2232,7 +2223,8 @@
                                      Status &error, size_t type_width) {
   size_t total_bytes_read = 0;
   if (dst && max_bytes && type_width && max_bytes >= type_width) {
-    // Ensure a null terminator independent of the number of bytes that is read.
+    // Ensure a null terminator independent of the number of bytes that is
+    // read.
     memset(dst, 0, max_bytes);
     size_t bytes_left = max_bytes - type_width;
 
@@ -2279,8 +2271,7 @@
 }
 
 // Deprecated in favor of ReadStringFromMemory which has wchar support and
-// correct code to find
-// null terminators.
+// correct code to find null terminators.
 size_t Process::ReadCStringFromMemory(addr_t addr, char *dst,
                                       size_t dst_max_len,
                                       Status &result_error) {
@@ -2344,8 +2335,8 @@
       break;
   }
 
-  // Replace any software breakpoint opcodes that fall into this range back
-  // into "buf" before we return
+  // Replace any software breakpoint opcodes that fall into this range
+  // back into "buf" before we return
   if (bytes_read > 0)
     RemoveBreakpointOpcodesFromBuffer(addr, bytes_read, (uint8_t *)buf);
   return bytes_read;
@@ -2420,9 +2411,9 @@
 
   m_mod_id.BumpMemoryID();
 
-  // We need to write any data that would go where any current software traps
-  // (enabled software breakpoints) any software traps (breakpoints) that we
-  // may have placed in our tasks memory.
+  // We need to write any data that would go where any current software
+  // traps (enabled software breakpoints) any software traps (breakpoints)
+  // that we may have placed in our tasks memory.
 
   BreakpointSiteList bp_sites_in_range;
 
@@ -2468,8 +2459,8 @@
                 error.SetErrorToGenericError();
             }
           }
-          // Now write any bytes that would cover up any software breakpoints
-          // directly into the breakpoint opcode buffer
+          // Now write any bytes that would cover up any software
+          // breakpoints directly into the breakpoint opcode buffer
           ::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset,
                    ubuf + bytes_written, intersect_size);
           bytes_written += intersect_size;
@@ -2484,7 +2475,8 @@
     return WriteMemoryPrivate(addr, buf, size, error);
   }
 
-  // Write any remaining bytes after the last breakpoint if we have any left
+  // Write any remaining bytes after the last breakpoint if we have any
+  // left
   return 0; // bytes_written;
 }
 
@@ -2742,9 +2734,10 @@
     exe_module->GetPlatformFileSpec().GetPath(platform_exec_file_path,
                                               sizeof(platform_exec_file_path));
     if (exe_module->GetFileSpec().Exists()) {
-      // Install anything that might need to be installed prior to launching.
-      // For host systems, this will do nothing, but if we are connected to a
-      // remote platform it will install any needed binaries
+      // Install anything that might need to be installed prior to
+      // launching. For host systems, this will do nothing, but if we are
+      // connected to a remote platform it will install any needed
+      // binaries
       error = GetTarget().Install(&launch_info);
       if (error.Fail())
         return error;
@@ -2779,8 +2772,8 @@
           StateType state = WaitForProcessStopPrivate(event_sp, seconds(10));
 
           if (state == eStateInvalid || !event_sp) {
-            // We were able to launch the process, but we failed to
-            // catch the initial stop.
+            // We were able to launch the process, but we failed to catch
+            // the initial stop.
             error.SetErrorString("failed to catch stop after launch");
             SetExitStatus(0, "failed to catch stop after launch");
             Destroy(false);
@@ -2800,17 +2793,15 @@
             if (!m_os_ap)
                 LoadOperatingSystemPlugin(false);
 
-            // We successfully launched the process and stopped,
-            // now it the right time to set up signal filters before resuming.
+            // We successfully launched the process and stopped, now it
+            // the right time to set up signal filters before resuming.
             UpdateAutomaticSignalFiltering();
 
-            // Note, the stop event was consumed above, but not handled. This
-            // was done
-            // to give DidLaunch a chance to run. The target is either stopped
-            // or crashed.
-            // Directly set the state.  This is done to prevent a stop message
-            // with a bunch
-            // of spurious output on thread status, as well as not pop a
+            // Note, the stop event was consumed above, but not handled.
+            // This was done to give DidLaunch a chance to run. The target
+            // is either stopped or crashed. Directly set the state.  This
+            // is done to prevent a stop message with a bunch of spurious
+            // output on thread status, as well as not pop a
             // ProcessIOHandler.
             SetPublicState(state, false);
 
@@ -2819,16 +2810,15 @@
             else
               StartPrivateStateThread();
 
-            // Target was stopped at entry as was intended. Need to notify the
-            // listeners
-            // about it.
+            // Target was stopped at entry as was intended. Need to notify
+            // the listeners about it.
             if (state == eStateStopped &&
                 launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
               HandlePrivateEvent(event_sp);
           } else if (state == eStateExited) {
-            // We exited while trying to launch somehow.  Don't call DidLaunch
-            // as that's
-            // not likely to work, and return an invalid pid.
+            // We exited while trying to launch somehow.  Don't call
+            // DidLaunch as that's not likely to work, and return an
+            // invalid pid.
             HandlePrivateEvent(event_sp);
           }
         }
@@ -2866,9 +2856,9 @@
     if (!m_os_ap)
       LoadOperatingSystemPlugin(false);
 
-    // We successfully loaded a core file, now pretend we stopped so we can
-    // show all of the threads in the core file and explore the crashed
-    // state.
+    // We successfully loaded a core file, now pretend we stopped so we
+    // can show all of the threads in the core file and explore the
+    // crashed state.
     SetPrivateState(eStateStopped);
 
     // Wait for a stopped event since we just posted one above...
@@ -2944,8 +2934,8 @@
     // During attach, prior to sending the eStateStopped event,
     // lldb_private::Process subclasses must set the new process ID.
     assert(m_process->GetID() != LLDB_INVALID_PROCESS_ID);
-    // We don't want these events to be reported, so go set the ShouldReportStop
-    // here:
+    // We don't want these events to be reported, so go set the
+    // ShouldReportStop here:
     m_process->GetThreadList().SetShouldReportStop(eVoteNo);
 
     if (m_exec_count > 0) {
@@ -3123,8 +3113,8 @@
   if (log)
     log->Printf("Process::%s()", __FUNCTION__);
 
-  // Let the process subclass figure out at much as it can about the process
-  // before we go looking for a dynamic loader plug-in.
+  // Let the process subclass figure out at much as it can about the
+  // process before we go looking for a dynamic loader plug-in.
   ArchSpec process_arch;
   DidAttach(process_arch);
 
@@ -3139,8 +3129,8 @@
   }
 
   // We just attached.  If we have a platform, ask it for the process
-  // architecture, and if it isn't
-  // the same as the one we've already set, switch architectures.
+  // architecture, and if it isn't the same as the one we've already set,
+  // switch architectures.
   PlatformSP platform_sp(GetTarget().GetPlatform());
   assert(platform_sp);
   if (platform_sp) {
@@ -3175,8 +3165,8 @@
     }
   }
 
-  // We have completed the attach, now it is time to find the dynamic loader
-  // plug-in
+  // We have completed the attach, now it is time to find the dynamic
+  // loader plug-in
   DynamicLoader *dyld = GetDynamicLoader();
   if (dyld) {
     dyld->DidAttach();
@@ -3250,8 +3240,8 @@
       StateType state = WaitForProcessStopPrivate(event_sp, llvm::None);
 
       if (state == eStateStopped || state == eStateCrashed) {
-        // If we attached and actually have a process on the other end, then
-        // this ended up being the equivalent of an attach.
+        // If we attached and actually have a process on the other end,
+        // then this ended up being the equivalent of an attach.
         CompleteAttach();
 
         // This delays passing the stopped event to listeners till
@@ -3277,20 +3267,19 @@
                 m_mod_id.GetStopID(), StateAsCString(m_public_state.GetValue()),
                 StateAsCString(m_private_state.GetValue()));
 
-  // If signals handing status changed we might want to update
-  // our signal filters before resuming.
+  // If signals handing status changed we might want to update our signal
+  // filters before resuming.
   UpdateAutomaticSignalFiltering();
 
   Status error(WillResume());
   // Tell the process it is about to resume before the thread list
   if (error.Success()) {
-    // Now let the thread list know we are about to resume so it
-    // can let all of our threads know that they are about to be
-    // resumed. Threads will each be called with
-    // Thread::WillResume(StateType) where StateType contains the state
-    // that they are supposed to have when the process is resumed
-    // (suspended/running/stepping). Threads should also check
-    // their resume signal in lldb::Thread::GetResumeSignal()
+    // Now let the thread list know we are about to resume so it can let
+    // all of our threads know that they are about to be resumed. Threads
+    // will each be called with Thread::WillResume(StateType) where
+    // StateType contains the state that they are supposed to have when
+    // the process is resumed (suspended/running/stepping). Threads should
+    // also check their resume signal in lldb::Thread::GetResumeSignal()
     // to see if they are supposed to start back up with a signal.
     if (m_thread_list.WillResume()) {
       // Last thing, do the PreResumeActions.
@@ -3308,10 +3297,9 @@
         }
       }
     } else {
-      // Somebody wanted to run without running (e.g. we were faking a step from
-      // one frame of a set of inlined
-      // frames that share the same PC to another.)  So generate a continue & a
-      // stopped event,
+      // Somebody wanted to run without running (e.g. we were faking a
+      // step from one frame of a set of inlined frames that share the
+      // same PC to another.)  So generate a continue & a stopped event,
       // and let the world handle them.
       if (log)
         log->Printf(
@@ -3331,8 +3319,8 @@
     return Status("Process is not running.");
 
   // Don't clear the m_clear_thread_plans_on_stop, only set it to true if
-  // in case it was already set and some thread plan logic calls halt on its
-  // own.
+  // in case it was already set and some thread plan logic calls halt on
+  // its own.
   m_clear_thread_plans_on_stop |= clear_thread_plans;
 
   ListenerSP halt_listener_sp(
@@ -3370,9 +3358,9 @@
 Status Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp) {
   Status error;
 
-  // Check both the public & private states here.  If we're hung evaluating an
-  // expression, for instance, then
-  // the public state will be stopped, but we still need to interrupt.
+  // Check both the public & private states here.  If we're hung
+  // evaluating an expression, for instance, then the public state will be
+  // stopped, but we still need to interrupt.
   if (m_public_state.GetValue() == eStateRunning ||
       m_private_state.GetValue() == eStateRunning) {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
@@ -3392,10 +3380,9 @@
     RestoreProcessEvents();
 
     // If the process exited while we were waiting for it to stop, put the
-    // exited event into
-    // the shared pointer passed in and return.  Our caller doesn't need to do
-    // anything else, since
-    // they don't have a process anymore...
+    // exited event into the shared pointer passed in and return.  Our
+    // caller doesn't need to do anything else, since they don't have a
+    // process anymore...
 
     if (state == eStateExited || m_private_state.GetValue() == eStateExited) {
       if (log)
@@ -3409,10 +3396,9 @@
       if (log)
         log->Printf("Process::%s() failed to stop, state is: %s", __FUNCTION__,
                     StateAsCString(state));
-      // If we really couldn't stop the process then we should just error out
-      // here, but if the
-      // lower levels just bobbled sending the event and we really are stopped,
-      // then continue on.
+      // If we really couldn't stop the process then we should just error
+      // out here, but if the lower levels just bobbled sending the event
+      // and we really are stopped, then continue on.
       StateType private_state = m_private_state.GetValue();
       if (private_state != eStateStopped) {
         return Status(
@@ -3439,8 +3425,8 @@
         m_destroy_in_process = false;
         return error;
       } else if (exit_event_sp) {
-        // We shouldn't need to do anything else here.  There's no process left
-        // to detach from...
+        // We shouldn't need to do anything else here.  There's no process
+        // left to detach from...
         StopPrivateStateThread();
         m_destroy_in_process = false;
         return error;
@@ -3460,20 +3446,19 @@
   }
   m_destroy_in_process = false;
 
-  // If we exited when we were waiting for a process to stop, then
-  // forward the event here so we don't lose the event
+  // If we exited when we were waiting for a process to stop, then forward
+  // the event here so we don't lose the event
   if (exit_event_sp) {
     // Directly broadcast our exited event because we shut down our
     // private state thread above
     BroadcastEvent(exit_event_sp);
   }
 
-  // If we have been interrupted (to kill us) in the middle of running, we may
-  // not end up propagating
-  // the last events through the event system, in which case we might strand the
-  // write lock.  Unlock
-  // it here so when we do to tear down the process we don't get an error
-  // destroying the lock.
+  // If we have been interrupted (to kill us) in the middle of running, we
+  // may not end up propagating the last events through the event system,
+  // in which case we might strand the write lock.  Unlock it here so when
+  // we do to tear down the process we don't get an error destroying the
+  // lock.
 
   m_public_run_lock.SetStopped();
   return error;
@@ -3481,12 +3466,11 @@
 
 Status Process::Destroy(bool force_kill) {
 
-  // Tell ourselves we are in the process of destroying the process, so that we
-  // don't do any unnecessary work
-  // that might hinder the destruction.  Remember to set this back to false when
-  // we are done.  That way if the attempt
-  // failed and the process stays around for some reason it won't be in a
-  // confused state.
+  // Tell ourselves we are in the process of destroying the process, so
+  // that we don't do any unnecessary work that might hinder the
+  // destruction.  Remember to set this back to false when we are done.
+  // That way if the attempt failed and the process stays around for some
+  // reason it won't be in a confused state.
 
   if (force_kill)
     m_should_detach = false;
@@ -3507,12 +3491,11 @@
     }
 
     if (m_public_state.GetValue() != eStateRunning) {
-      // Ditch all thread plans, and remove all our breakpoints: in case we have
-      // to restart the target to
-      // kill it, we don't want it hitting a breakpoint...
-      // Only do this if we've stopped, however, since if we didn't manage to
-      // halt it above, then
-      // we're not going to have much luck doing this now.
+      // Ditch all thread plans, and remove all our breakpoints: in case
+      // we have to restart the target to kill it, we don't want it
+      // hitting a breakpoint... Only do this if we've stopped, however,
+      // since if we didn't manage to halt it above, then we're not going
+      // to have much luck doing this now.
       m_thread_list.DiscardThreadPlans();
       DisableAllBreakpointSites();
     }
@@ -3540,11 +3523,10 @@
       BroadcastEvent(exit_event_sp);
     }
 
-    // If we have been interrupted (to kill us) in the middle of running, we may
-    // not end up propagating
-    // the last events through the event system, in which case we might strand
-    // the write lock.  Unlock
-    // it here so when we do to tear down the process we don't get an error
+    // If we have been interrupted (to kill us) in the middle of running,
+    // we may not end up propagating the last events through the event
+    // system, in which case we might strand the write lock.  Unlock it
+    // here so when we do to tear down the process we don't get an error
     // destroying the lock.
     m_public_run_lock.SetStopped();
   }
@@ -3602,8 +3584,8 @@
   case eStateConnected:
   case eStateAttaching:
   case eStateLaunching:
-    // These events indicate changes in the state of the debugging session,
-    // always report them.
+    // These events indicate changes in the state of the debugging
+    // session, always report them.
     return_value = true;
     break;
   case eStateInvalid:
@@ -3614,9 +3596,9 @@
   case eStateStepping:
     // If we've started the target running, we handle the cases where we
     // are already running and where there is a transition from stopped to
-    // running differently.
-    // running -> running: Automatically suppress extra running events
-    // stopped -> running: Report except when there is one or more no votes
+    // running differently. running -> running: Automatically suppress
+    // extra running events stopped -> running: Report except when there
+    // is one or more no votes
     //     and no yes votes.
     SynchronouslyNotifyStateChanged(state);
     if (m_force_next_event_delivery)
@@ -3625,16 +3607,17 @@
       switch (m_last_broadcast_state) {
       case eStateRunning:
       case eStateStepping:
-        // We always suppress multiple runnings with no PUBLIC stop in between.
+        // We always suppress multiple runnings with no PUBLIC stop in
+        // between.
         return_value = false;
         break;
       default:
-        // TODO: make this work correctly. For now always report
-        // run if we aren't running so we don't miss any running
-        // events. If I run the lldb/test/thread/a.out file and
-        // break at main.cpp:58, run and hit the breakpoints on
-        // multiple threads, then somehow during the stepping over
-        // of all breakpoints no run gets reported.
+        // TODO: make this work correctly. For now always report run if we
+        // aren't running so we don't miss any running events. If I run
+        // the lldb/test/thread/a.out file and break at main.cpp:58, run
+        // and hit the breakpoints on multiple threads, then somehow
+        // during the stepping over of all breakpoints no run gets
+        // reported.
 
         // This is a transition from stop to run.
         switch (m_thread_list.ShouldReportRun(event_ptr)) {
@@ -3653,11 +3636,10 @@
   case eStateStopped:
   case eStateCrashed:
   case eStateSuspended:
-    // We've stopped.  First see if we're going to restart the target.
-    // If we are going to stop, then we always broadcast the event.
-    // If we aren't going to stop, let the thread plans decide if we're going to
-    // report this event.
-    // If no thread has an opinion, we don't report it.
+    // We've stopped.  First see if we're going to restart the target. If
+    // we are going to stop, then we always broadcast the event. If we
+    // aren't going to stop, let the thread plans decide if we're going to
+    // report this event. If no thread has an opinion, we don't report it.
 
     m_stdio_communication.SynchronizeWithReadThread();
     RefreshStateAfterStop();
@@ -3666,9 +3648,9 @@
         log->Printf("Process::ShouldBroadcastEvent (%p) stopped due to an "
                     "interrupt, state: %s",
                     static_cast<void *>(event_ptr), StateAsCString(state));
-      // Even though we know we are going to stop, we should let the threads
-      // have a look at the stop,
-      // so they can properly set their state.
+      // Even though we know we are going to stop, we should let the
+      // threads have a look at the stop, so they can properly set their
+      // state.
       m_thread_list.ShouldStop(event_ptr);
       return_value = true;
     } else {
@@ -3676,10 +3658,9 @@
       bool should_resume = false;
 
       // It makes no sense to ask "ShouldStop" if we've already been
-      // restarted...
-      // Asking the thread list is also not likely to go well, since we are
-      // running again.
-      // So in that case just report the event.
+      // restarted... Asking the thread list is also not likely to go
+      // well, since we are running again. So in that case just report the
+      // event.
 
       if (!was_restarted)
         should_resume = !m_thread_list.ShouldStop(event_ptr);
@@ -3718,20 +3699,18 @@
     break;
   }
 
-  // Forcing the next event delivery is a one shot deal.  So reset it here.
+  // Forcing the next event delivery is a one shot deal.  So reset it
+  // here.
   m_force_next_event_delivery = false;
 
   // We do some coalescing of events (for instance two consecutive running
-  // events get coalesced.)
-  // But we only coalesce against events we actually broadcast.  So we use
-  // m_last_broadcast_state
-  // to track that.  NB - you can't use "m_public_state.GetValue()" for that
-  // purpose, as was originally done,
-  // because the PublicState reflects the last event pulled off the queue, and
-  // there may be several
-  // events stacked up on the queue unserviced.  So the PublicState may not
-  // reflect the last broadcasted event
-  // yet.  m_last_broadcast_state gets updated here.
+  // events get coalesced.) But we only coalesce against events we
+  // actually broadcast.  So we use m_last_broadcast_state to track that.
+  // NB - you can't use "m_public_state.GetValue()" for that purpose, as
+  // was originally done, because the PublicState reflects the last event
+  // pulled off the queue, and there may be several events stacked up on
+  // the queue unserviced.  So the PublicState may not reflect the last
+  // broadcasted event yet.  m_last_broadcast_state gets updated here.
 
   if (return_value)
     m_last_broadcast_state = state;
@@ -3762,8 +3741,8 @@
   char thread_name[1024];
   uint32_t max_len = llvm::get_max_thread_name_length();
   if (max_len > 0 && max_len <= 30) {
-    // On platforms with abbreviated thread name lengths, choose thread names
-    // that fit within the limit.
+    // On platforms with abbreviated thread name lengths, choose thread
+    // names that fit within the limit.
     if (already_running)
       snprintf(thread_name, sizeof(thread_name), "intern-state-OV");
     else
@@ -3823,10 +3802,10 @@
   // Signal the private state thread
   if (m_private_state_thread.IsJoinable()) {
     // Broadcast the event.
-    // It is important to do this outside of the if below, because
-    // it's possible that the thread state is invalid but that the
-    // thread is waiting on a control event instead of simply being
-    // on its way out (this should not happen, but it apparently can).
+    // It is important to do this outside of the if below, because it's
+    // possible that the thread state is invalid but that the thread is
+    // waiting on a control event instead of simply being on its way out
+    // (this should not happen, but it apparently can).
     if (log)
       log->Printf("Sending control event of type: %d.", signal);
     std::shared_ptr<EventDataReceipt> event_receipt_sp(new EventDataReceipt());
@@ -3838,13 +3817,13 @@
     if (PrivateStateThreadIsValid()) {
       while (!receipt_received) {
         bool timed_out = false;
-        // Check for a receipt for 2 seconds and then check if the private state
-        // thread is still around.
+        // Check for a receipt for 2 seconds and then check if the private
+        // state thread is still around.
         receipt_received = event_receipt_sp->WaitForEventReceived(
             std::chrono::seconds(2), &timed_out);
         if (!receipt_received) {
-          // Check if the private state thread is still around. If it isn't then
-          // we are done waiting
+          // Check if the private state thread is still around. If it
+          // isn't then we are done waiting
           if (!PrivateStateThreadIsValid())
             break; // Private state thread exited or is exiting, we are done
         }
@@ -3894,9 +3873,9 @@
       break;
 
     case NextEventAction::eEventActionExit:
-      // Handle Exiting Here.  If we already got an exited event,
-      // we should just propagate it.  Otherwise, swallow this event,
-      // and set our state to exit so the next event will kill us.
+      // Handle Exiting Here.  If we already got an exited event, we
+      // should just propagate it.  Otherwise, swallow this event, and set
+      // our state to exit so the next event will kill us.
       if (new_state != eStateExited) {
         // FIXME: should cons up an exited event, and discard this one.
         SetExitStatus(0, m_next_event_action_ap->GetExitString());
@@ -3922,9 +3901,9 @@
     }
     Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get());
     if (StateIsRunningState(new_state)) {
-      // Only push the input handler if we aren't fowarding events,
-      // as this means the curses GUI is in use...
-      // Or don't push it if we are launching since it will come up stopped.
+      // Only push the input handler if we aren't fowarding events, as
+      // this means the curses GUI is in use... Or don't push it if we are
+      // launching since it will come up stopped.
       if (!GetTarget().GetDebugger().IsForwardingEvents() &&
           new_state != eStateLaunching && new_state != eStateAttaching) {
         PushProcessIOHandler();
@@ -3940,31 +3919,31 @@
         // want to pop the process IOHandler here, we want to do it when
         // we receive the stopped event so we can carefully control when
         // the process IOHandler is popped because when we stop we want to
-        // display some text stating how and why we stopped, then maybe some
-        // process/thread/frame info, and then we want the "(lldb) " prompt
-        // to show up. If we pop the process IOHandler here, then we will
-        // cause the command interpreter to become the top IOHandler after
-        // the process pops off and it will update its prompt right away...
-        // See the Debugger.cpp file where it calls the function as
-        // "process_sp->PopProcessIOHandler()" to see where I am talking about.
-        // Otherwise we end up getting overlapping "(lldb) " prompts and
-        // garbled output.
+        // display some text stating how and why we stopped, then maybe
+        // some process/thread/frame info, and then we want the "(lldb) "
+        // prompt to show up. If we pop the process IOHandler here, then
+        // we will cause the command interpreter to become the top
+        // IOHandler after the process pops off and it will update its
+        // prompt right away... See the Debugger.cpp file where it calls
+        // the function as "process_sp->PopProcessIOHandler()" to see
+        // where I am talking about. Otherwise we end up getting
+        // overlapping "(lldb) " prompts and garbled output.
         //
-        // If we aren't handling the events in the debugger (which is indicated
-        // by "m_target.GetDebugger().IsHandlingEvents()" returning false) or we
-        // are hijacked, then we always pop the process IO handler manually.
-        // Hijacking happens when the internal process state thread is running
-        // thread plans, or when commands want to run in synchronous mode
-        // and they call "process->WaitForProcessToStop()". An example of
-        // something
-        // that will hijack the events is a simple expression:
+        // If we aren't handling the events in the debugger (which is
+        // indicated by "m_target.GetDebugger().IsHandlingEvents()"
+        // returning false) or we are hijacked, then we always pop the
+        // process IO handler manually. Hijacking happens when the
+        // internal process state thread is running thread plans, or when
+        // commands want to run in synchronous mode and they call
+        // "process->WaitForProcessToStop()". An example of something that
+        // will hijack the events is a simple expression:
         //
         //  (lldb) expr (int)puts("hello")
         //
-        // This will cause the internal process state thread to resume and halt
-        // the process (and _it_ will hijack the eBroadcastBitStateChanged
-        // events) and we do need the IO handler to be pushed and popped
-        // correctly.
+        // This will cause the internal process state thread to resume and
+        // halt the process (and _it_ will hijack the
+        // eBroadcastBitStateChanged events) and we do need the IO handler
+        // to be pushed and popped correctly.
 
         if (is_hijacked || !GetTarget().GetDebugger().IsHandlingEvents())
           PopProcessIOHandler();
@@ -4059,23 +4038,19 @@
                       ") failed to halt the process: %s",
                       __FUNCTION__, static_cast<void *>(this), GetID(),
                       error.AsCString());
-        // Halt should generate a stopped event. Make a note of the fact that we
-        // were
-        // doing the interrupt, so we can set the interrupted flag after we
-        // receive the
-        // event. We deliberately set this to true even if HaltPrivate failed,
-        // so that we
-        // can interrupt on the next natural stop.
+        // Halt should generate a stopped event. Make a note of the fact
+        // that we were doing the interrupt, so we can set the interrupted
+        // flag after we receive the event. We deliberately set this to
+        // true even if HaltPrivate failed, so that we can interrupt on
+        // the next natural stop.
         interrupt_requested = true;
       } else {
-        // This can happen when someone (e.g. Process::Halt) sees that we are
-        // running and
-        // sends an interrupt request, but the process actually stops before we
-        // receive
-        // it. In that case, we can just ignore the request. We use
-        // m_last_broadcast_state, because the Stopped event may not have been
-        // popped of
-        // the event queue yet, which is when the public state gets updated.
+        // This can happen when someone (e.g. Process::Halt) sees that we
+        // are running and sends an interrupt request, but the process
+        // actually stops before we receive it. In that case, we can just
+        // ignore the request. We use m_last_broadcast_state, because the
+        // Stopped event may not have been popped of the event queue yet,
+        // which is when the public state gets updated.
         if (log)
           log->Printf(
               "Process::%s ignoring interrupt as we have already stopped.",
@@ -4096,9 +4071,9 @@
 
       if (interrupt_requested) {
         if (StateIsStoppedState(internal_state, true)) {
-          // We requested the interrupt, so mark this as such in the stop event
-          // so
-          // clients can tell an interrupted process from a natural stop
+          // We requested the interrupt, so mark this as such in the stop
+          // event so clients can tell an interrupted process from a
+          // natural stop
           ProcessEventData::SetInterruptedInEvent(event_sp.get(), true);
           interrupt_requested = false;
         } else if (log) {
@@ -4128,11 +4103,9 @@
     log->Printf("Process::%s (arg = %p, pid = %" PRIu64 ") thread exiting...",
                 __FUNCTION__, static_cast<void *>(this), GetID());
 
-  // If we are a secondary thread, then the primary thread we are working for
-  // will have already
-  // acquired the public_run_lock, and isn't done with what it was doing yet, so
-  // don't
-  // try to change it on the way out.
+  // If we are a secondary thread, then the primary thread we are working
+  // for will have already acquired the public_run_lock, and isn't done
+  // with what it was doing yet, so don't try to change it on the way out.
   if (!is_secondary_thread)
     m_public_run_lock.SetStopped();
   return NULL;
@@ -4171,16 +4144,14 @@
   if (!process_sp)
     return;
 
-  // This function gets called twice for each event, once when the event gets
-  // pulled
-  // off of the private process event queue, and then any number of times, first
-  // when it gets pulled off of
-  // the public event queue, then other times when we're pretending that this is
-  // where we stopped at the
-  // end of expression evaluation.  m_update_state is used to distinguish these
-  // three cases; it is 0 when we're just pulling it off for private handling,
-  // and > 1 for expression evaluation, and we don't want to do the breakpoint
-  // command handling then.
+  // This function gets called twice for each event, once when the event
+  // gets pulled off of the private process event queue, and then any
+  // number of times, first when it gets pulled off of the public event
+  // queue, then other times when we're pretending that this is where we
+  // stopped at the end of expression evaluation.  m_update_state is used
+  // to distinguish these three cases; it is 0 when we're just pulling it
+  // off for private handling, and > 1 for expression evaluation, and we
+  // don't want to do the breakpoint command handling then.
   if (m_update_state != 1)
     return;
 
@@ -4188,58 +4159,55 @@
       m_state, Process::ProcessEventData::GetRestartedFromEvent(event_ptr));
 
   if (m_state == eStateStopped && !m_restarted) {
-    // Let process subclasses know we are about to do a public stop and
-    // do anything they might need to in order to speed up register and
+    // Let process subclasses know we are about to do a public stop and do
+    // anything they might need to in order to speed up register and
     // memory accesses.
     process_sp->WillPublicStop();
   }
 
-  // If this is a halt event, even if the halt stopped with some reason other
-  // than a plain interrupt (e.g. we had
-  // already stopped for a breakpoint when the halt request came through) don't
-  // do the StopInfo actions, as they may
-  // end up restarting the process.
+  // If this is a halt event, even if the halt stopped with some reason
+  // other than a plain interrupt (e.g. we had already stopped for a
+  // breakpoint when the halt request came through) don't do the StopInfo
+  // actions, as they may end up restarting the process.
   if (m_interrupted)
     return;
 
-  // If we're stopped and haven't restarted, then do the StopInfo actions here:
+  // If we're stopped and haven't restarted, then do the StopInfo actions
+  // here:
   if (m_state == eStateStopped && !m_restarted) {
     ThreadList &curr_thread_list = process_sp->GetThreadList();
     uint32_t num_threads = curr_thread_list.GetSize();
     uint32_t idx;
 
-    // The actions might change one of the thread's stop_info's opinions about
-    // whether we should
-    // stop the process, so we need to query that as we go.
-
-    // One other complication here, is that we try to catch any case where the
-    // target has run (except for expressions)
-    // and immediately exit, but if we get that wrong (which is possible) then
-    // the thread list might have changed, and
-    // that would cause our iteration here to crash.  We could make a copy of
-    // the thread list, but we'd really like
-    // to also know if it has changed at all, so we make up a vector of the
-    // thread ID's and check what we get back
-    // against this list & bag out if anything differs.
+    // The actions might change one of the thread's stop_info's opinions
+    // about whether we should stop the process, so we need to query that
+    // as we go.
+
+    // One other complication here, is that we try to catch any case where
+    // the target has run (except for expressions) and immediately exit,
+    // but if we get that wrong (which is possible) then the thread list
+    // might have changed, and that would cause our iteration here to
+    // crash.  We could make a copy of the thread list, but we'd really
+    // like to also know if it has changed at all, so we make up a vector
+    // of the thread ID's and check what we get back against this list &
+    // bag out if anything differs.
     std::vector<uint32_t> thread_index_array(num_threads);
     for (idx = 0; idx < num_threads; ++idx)
       thread_index_array[idx] =
           curr_thread_list.GetThreadAtIndex(idx)->GetIndexID();
 
-    // Use this to track whether we should continue from here.  We will only
-    // continue the target running if
-    // no thread says we should stop.  Of course if some thread's PerformAction
-    // actually sets the target running,
-    // then it doesn't matter what the other threads say...
+    // Use this to track whether we should continue from here.  We will
+    // only continue the target running if no thread says we should stop.
+    // Of course if some thread's PerformAction actually sets the target
+    // running, then it doesn't matter what the other threads say...
 
     bool still_should_stop = false;
 
-    // Sometimes - for instance if we have a bug in the stub we are talking to,
-    // we stop but no thread has a
-    // valid stop reason.  In that case we should just stop, because we have no
-    // way of telling what the right
-    // thing to do is, and it's better to let the user decide than continue
-    // behind their backs.
+    // Sometimes - for instance if we have a bug in the stub we are
+    // talking to, we stop but no thread has a valid stop reason.  In that
+    // case we should just stop, because we have no way of telling what
+    // the right thing to do is, and it's better to let the user decide
+    // than continue behind their backs.
 
     bool does_anybody_have_an_opinion = false;
 
@@ -4276,13 +4244,12 @@
               stop_info_sp->GetOverriddenShouldStopValue();
         } else {
           stop_info_sp->PerformAction(event_ptr);
-          // The stop action might restart the target.  If it does, then we want
-          // to mark that in the
-          // event so that whoever is receiving it will know to wait for the
-          // running event and reflect
-          // that state appropriately.
-          // We also need to stop processing actions, since they aren't
-          // expecting the target to be running.
+          // The stop action might restart the target.  If it does, then
+          // we want to mark that in the event so that whoever is
+          // receiving it will know to wait for the running event and
+          // reflect that state appropriately. We also need to stop
+          // processing actions, since they aren't expecting the target to
+          // be running.
 
           // FIXME: we might have run.
           if (stop_info_sp->HasTargetRunSinceMe()) {
@@ -4302,12 +4269,12 @@
       if (!still_should_stop && does_anybody_have_an_opinion) {
         // We've been asked to continue, so do that here.
         SetRestarted(true);
-        // Use the public resume method here, since this is just
-        // extending a public resume.
+        // Use the public resume method here, since this is just extending
+        // a public resume.
         process_sp->PrivateResume();
       } else {
-        // If we didn't restart, run the Stop Hooks here:
-        // They might also restart the target, so watch for that.
+        // If we didn't restart, run the Stop Hooks here: They might also
+        // restart the target, so watch for that.
         process_sp->GetTarget().RunStopHooks();
         if (process_sp->GetPrivateState() == eStateRunning)
           SetRestarted(true);
@@ -4438,8 +4405,8 @@
 }
 
 // uint32_t
-// Process::ListProcessesMatchingName (const char *name, StringList &matches,
-// std::vector<lldb::pid_t> &pids)
+// Process::ListProcessesMatchingName (const char *name, StringList
+// &matches, std::vector<lldb::pid_t> &pids)
 //{
 //    return 0;
 //}
@@ -4579,9 +4546,8 @@
 
   ~IOHandlerProcessSTDIO() override = default;
 
-  // Each IOHandler gets to run until it is done. It should read data
-  // from the "in" and place output into "out" and "err and return
-  // when done.
+  // Each IOHandler gets to run until it is done. It should read data from
+  // the "in" and place output into "out" and "err and return when done.
   void Run() override {
     if (!m_read_file.IsValid() || !m_write_file.IsValid() ||
         !m_pipe.CanRead() || !m_pipe.CanWrite()) {
@@ -4645,17 +4611,17 @@
   void Cancel() override {
     SetIsDone(true);
     // Only write to our pipe to cancel if we are in
-    // IOHandlerProcessSTDIO::Run().
-    // We can end up with a python command that is being run from the command
-    // interpreter:
+    // IOHandlerProcessSTDIO::Run(). We can end up with a python command
+    // that is being run from the command interpreter:
     //
     // (lldb) step_process_thousands_of_times
     //
-    // In this case the command interpreter will be in the middle of handling
-    // the command and if the process pushes and pops the IOHandler thousands
-    // of times, we can end up writing to m_pipe without ever consuming the
-    // bytes from the pipe in IOHandlerProcessSTDIO::Run() and end up
-    // deadlocking when the pipe gets fed up and blocks until data is consumed.
+    // In this case the command interpreter will be in the middle of
+    // handling the command and if the process pushes and pops the
+    // IOHandler thousands of times, we can end up writing to m_pipe
+    // without ever consuming the bytes from the pipe in
+    // IOHandlerProcessSTDIO::Run() and end up deadlocking when the pipe
+    // gets fed up and blocks until data is consumed.
     if (m_is_running) {
       char ch = 'q'; // Send 'q' for quit
       size_t bytes_written = 0;
@@ -4665,11 +4631,10 @@
 
   bool Interrupt() override {
     // Do only things that are safe to do in an interrupt context (like in
-    // a SIGINT handler), like write 1 byte to a file descriptor. This will
-    // interrupt the IOHandlerProcessSTDIO::Run() and we can look at the byte
-    // that was written to the pipe and then call
-    // m_process->SendAsyncInterrupt()
-    // from a much safer location in code.
+    // a SIGINT handler), like write 1 byte to a file descriptor. This
+    // will interrupt the IOHandlerProcessSTDIO::Run() and we can look at
+    // the byte that was written to the pipe and then call
+    // m_process->SendAsyncInterrupt() from a much safer location in code.
     if (m_active) {
       char ch = 'i'; // Send 'i' for interrupt
       size_t bytes_written = 0;
@@ -4677,16 +4642,13 @@
       return result.Success();
     } else {
       // This IOHandler might be pushed on the stack, but not being run
-      // currently
-      // so do the right thing if we aren't actively watching for STDIN by
-      // sending
-      // the interrupt to the process. Otherwise the write to the pipe above
-      // would
-      // do nothing. This can happen when the command interpreter is running and
-      // gets a "expression ...". It will be on the IOHandler thread and sending
-      // the input is complete to the delegate which will cause the expression
-      // to
-      // run, which will push the process IO handler, but not run it.
+      // currently so do the right thing if we aren't actively watching
+      // for STDIN by sending the interrupt to the process. Otherwise the
+      // write to the pipe above would do nothing. This can happen when
+      // the command interpreter is running and gets a "expression ...".
+      // It will be on the IOHandler thread and sending the input is
+      // complete to the delegate which will cause the expression to run,
+      // which will push the process IO handler, but not run it.
 
       if (StateIsRunningState(m_process->GetState())) {
         m_process->SendAsyncInterrupt();
@@ -4761,12 +4723,11 @@
 void Process::SettingsTerminate() { Thread::SettingsTerminate(); }
 
 namespace {
-// RestorePlanState is used to record the "is private", "is master" and "okay to
-// discard" fields of
-// the plan we are running, and reset it on Clean or on destruction.
-// It will only reset the state once, so you can call Clean and then monkey with
-// the state and it
-// won't get reset on you again.
+// RestorePlanState is used to record the "is private", "is master" and
+// "okay to discard" fields of the plan we are running, and reset it on
+// Clean or on destruction. It will only reset the state once, so you can
+// call Clean and then monkey with the state and it won't get reset on you
+// again.
 
 class RestorePlanState {
 public:
@@ -4847,8 +4808,8 @@
   if (plan == thread_plan_sp && plan->PlanSucceeded()) {
     LLDB_LOG(log, "execution completed successfully");
 
-    // Restore the plan state so it will get reported as intended when we are
-    // done.
+    // Restore the plan state so it will get reported as intended when we
+    // are done.
     restorer.Clean();
     return eExpressionCompleted;
   }
@@ -4858,9 +4819,10 @@
       stop_info_sp->ShouldNotify(event_sp.get())) {
     LLDB_LOG(log, "stopped for breakpoint: {0}.", stop_info_sp->GetDescription());
     if (!options.DoesIgnoreBreakpoints()) {
-      // Restore the plan state and then force Private to false.  We are going
-      // to stop because of this plan so we need it to become a public plan or
-      // it won't report correctly when we continue to its termination later on.
+      // Restore the plan state and then force Private to false.  We are
+      // going to stop because of this plan so we need it to become a
+      // public plan or it won't report correctly when we continue to its
+      // termination later on.
       restorer.Clean();
       thread_plan_sp->SetPrivate(false);
       event_to_broadcast_sp = event_sp;
@@ -4914,24 +4876,21 @@
     return eExpressionSetupError;
   }
 
-  // We need to change some of the thread plan attributes for the thread plan
-  // runner.  This will restore them
-  // when we are done:
+  // We need to change some of the thread plan attributes for the thread
+  // plan runner.  This will restore them when we are done:
 
   RestorePlanState thread_plan_restorer(thread_plan_sp);
 
-  // We rely on the thread plan we are running returning "PlanCompleted" if when
-  // it successfully completes.
-  // For that to be true the plan can't be private - since private plans
-  // suppress themselves in the
+  // We rely on the thread plan we are running returning "PlanCompleted"
+  // if when it successfully completes. For that to be true the plan can't
+  // be private - since private plans suppress themselves in the
   // GetCompletedPlan call.
 
   thread_plan_sp->SetPrivate(false);
 
-  // The plans run with RunThreadPlan also need to be terminal master plans or
-  // when they are done we will end
-  // up asking the plan above us whether we should stop, which may give the
-  // wrong answer.
+  // The plans run with RunThreadPlan also need to be terminal master
+  // plans or when they are done we will end up asking the plan above us
+  // whether we should stop, which may give the wrong answer.
 
   thread_plan_sp->SetIsMasterPlan(true);
   thread_plan_sp->SetOkayToDiscard(false);
@@ -4958,8 +4917,8 @@
     }
   }
 
-  // Make sure the timeout values make sense. The one thread timeout needs to be
-  // smaller than the overall timeout.
+  // Make sure the timeout values make sense. The one thread timeout needs
+  // to be smaller than the overall timeout.
   if (options.GetOneThreadTimeout() && options.GetTimeout() &&
       *options.GetTimeout() < *options.GetOneThreadTimeout()) {
     diagnostic_manager.PutString(eDiagnosticSeverityError,
@@ -4970,9 +4929,9 @@
 
   StackID ctx_frame_id = selected_frame_sp->GetStackID();
 
-  // N.B. Running the target may unset the currently selected thread and frame.
-  // We don't want to do that either,
-  // so we should arrange to reset them as well.
+  // N.B. Running the target may unset the currently selected thread and
+  // frame. We don't want to do that either, so we should arrange to reset
+  // them as well.
 
   lldb::ThreadSP selected_thread_sp = GetThreadList().GetSelectedThread();
 
@@ -4992,12 +4951,11 @@
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STEP |
                                                   LIBLLDB_LOG_PROCESS));
   if (m_private_state_thread.EqualsThread(Host::GetCurrentThread())) {
-    // Yikes, we are running on the private state thread!  So we can't wait for
-    // public events on this thread, since
-    // we are the thread that is generating public events.
-    // The simplest thing to do is to spin up a temporary thread to handle
-    // private state thread events while
-    // we are fielding public events here.
+    // Yikes, we are running on the private state thread!  So we can't
+    // wait for public events on this thread, since we are the thread that
+    // is generating public events. The simplest thing to do is to spin up
+    // a temporary thread to handle private state thread events while we
+    // are fielding public events here.
     if (log)
       log->Printf("Running thread plan on private state thread, spinning up "
                   "another state thread to handle the events.");
@@ -5005,15 +4963,12 @@
     backup_private_state_thread = m_private_state_thread;
 
     // One other bit of business: we want to run just this thread plan and
-    // anything it pushes, and then stop,
-    // returning control here.
-    // But in the normal course of things, the plan above us on the stack would
-    // be given a shot at the stop
-    // event before deciding to stop, and we don't want that.  So we insert a
-    // "stopper" base plan on the stack
-    // before the plan we want to run.  Since base plans always stop and return
-    // control to the user, that will
-    // do just what we want.
+    // anything it pushes, and then stop, returning control here. But in
+    // the normal course of things, the plan above us on the stack would
+    // be given a shot at the stop event before deciding to stop, and we
+    // don't want that.  So we insert a "stopper" base plan on the stack
+    // before the plan we want to run.  Since base plans always stop and
+    // return control to the user, that will do just what we want.
     stopper_base_plan_sp.reset(new ThreadPlanBase(*thread));
     thread->QueueThreadPlan(stopper_base_plan_sp, false);
     // Have to make sure our public state is stopped, since otherwise the
@@ -5029,15 +4984,12 @@
       thread_plan_sp, false); // This used to pass "true" does that make sense?
 
   if (options.GetDebug()) {
-    // In this case, we aren't actually going to run, we just want to stop right
-    // away.
-    // Flush this thread so we will refetch the stacks and show the correct
-    // backtrace.
-    // FIXME: To make this prettier we should invent some stop reason for this,
-    // but that
-    // is only cosmetic, and this functionality is only of use to lldb
-    // developers who can
-    // live with not pretty...
+    // In this case, we aren't actually going to run, we just want to stop
+    // right away. Flush this thread so we will refetch the stacks and
+    // show the correct backtrace. FIXME: To make this prettier we should
+    // invent some stop reason for this, but that is only cosmetic, and
+    // this functionality is only of use to lldb developers who can live
+    // with not pretty...
     thread->Flush();
     return eExpressionStoppedForDebug;
   }
@@ -5048,13 +5000,13 @@
   lldb::EventSP event_to_broadcast_sp;
 
   {
-    // This process event hijacker Hijacks the Public events and its destructor
-    // makes sure that the process events get
-    // restored on exit to the function.
+    // This process event hijacker Hijacks the Public events and its
+    // destructor makes sure that the process events get restored on exit
+    // to the function.
     //
-    // If the event needs to propagate beyond the hijacker (e.g., the process
-    // exits during execution), then the event
-    // is put into event_to_broadcast_sp for rebroadcasting.
+    // If the event needs to propagate beyond the hijacker (e.g., the
+    // process exits during execution), then the event is put into
+    // event_to_broadcast_sp for rebroadcasting.
 
     ProcessEventHijacker run_thread_plan_hijacker(*this, listener_sp);
 
@@ -5078,9 +5030,9 @@
     // This is just for accounting:
     uint32_t num_resumes = 0;
 
-    // If we are going to run all threads the whole time, or if we are only
-    // going to run one thread, then we don't need the first timeout.  So we
-    // pretend we are after the first timeout already.
+    // If we are going to run all threads the whole time, or if we are
+    // only going to run one thread, then we don't need the first timeout.
+    // So we pretend we are after the first timeout already.
     if (!options.GetStopOthers() || !options.GetTryAllThreads())
       before_first_timeout = false;
 
@@ -5089,10 +5041,10 @@
                   options.GetStopOthers(), options.GetTryAllThreads(),
                   before_first_timeout);
 
-    // This isn't going to work if there are unfetched events on the queue.
-    // Are there cases where we might want to run the remaining events here, and
-    // then try to
-    // call the function?  That's probably being too tricky for our own good.
+    // This isn't going to work if there are unfetched events on the
+    // queue. Are there cases where we might want to run the remaining
+    // events here, and then try to call the function?  That's probably
+    // being too tricky for our own good.
 
     Event *other_events = listener_sp->PeekAtNextEvent();
     if (other_events != nullptr) {
@@ -5102,41 +5054,38 @@
       return eExpressionSetupError;
     }
 
-    // We also need to make sure that the next event is delivered.  We might be
-    // calling a function as part of
-    // a thread plan, in which case the last delivered event could be the
-    // running event, and we don't want
-    // event coalescing to cause us to lose OUR running event...
+    // We also need to make sure that the next event is delivered.  We
+    // might be calling a function as part of a thread plan, in which case
+    // the last delivered event could be the running event, and we don't
+    // want event coalescing to cause us to lose OUR running event...
     ForceNextEventDelivery();
 
-// This while loop must exit out the bottom, there's cleanup that we need to do
-// when we are done.
-// So don't call return anywhere within it.
+// This while loop must exit out the bottom, there's cleanup that we need
+// to do when we are done. So don't call return anywhere within it.
 
 #ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
     // It's pretty much impossible to write test cases for things like:
-    // One thread timeout expires, I go to halt, but the process already stopped
-    // on the function call stop breakpoint.  Turning on this define will make
-    // us not
-    // fetch the first event till after the halt.  So if you run a quick
-    // function, it will have
-    // completed, and the completion event will be waiting, when you interrupt
-    // for halt.
-    // The expression evaluation should still succeed.
+    // One thread timeout expires, I go to halt, but the process already
+    // stopped on the function call stop breakpoint.  Turning on this
+    // define will make us not fetch the first event till after the halt.
+    // So if you run a quick function, it will have completed, and the
+    // completion event will be waiting, when you interrupt for halt. The
+    // expression evaluation should still succeed.
     bool miss_first_event = true;
 #endif
     while (true) {
-      // We usually want to resume the process if we get to the top of the loop.
-      // The only exception is if we get two running events with no intervening
-      // stop, which can happen, we will just wait for then next stop event.
+      // We usually want to resume the process if we get to the top of the
+      // loop. The only exception is if we get two running events with no
+      // intervening stop, which can happen, we will just wait for then
+      // next stop event.
       if (log)
         log->Printf("Top of while loop: do_resume: %i handle_running_event: %i "
                     "before_first_timeout: %i.",
                     do_resume, handle_running_event, before_first_timeout);
 
       if (do_resume || handle_running_event) {
-        // Do the initial resume and wait for the running event before going
-        // further.
+        // Do the initial resume and wait for the running event before
+        // going further.
 
         if (do_resume) {
           num_resumes++;
@@ -5186,10 +5135,9 @@
           }
 
           if (restarted) {
-            // This is probably an overabundance of caution, I don't think I
-            // should ever get a stopped & restarted
-            // event here.  But if I do, the best thing is to Halt and then get
-            // out of here.
+            // This is probably an overabundance of caution, I don't think
+            // I should ever get a stopped & restarted event here.  But if
+            // I do, the best thing is to Halt and then get out of here.
             const bool clear_thread_plans = false;
             const bool use_run_lock = false;
             Halt(clear_thread_plans, use_run_lock);
@@ -5205,14 +5153,12 @@
 
         if (log)
           log->PutCString("Process::RunThreadPlan(): resuming succeeded.");
-        // We need to call the function synchronously, so spin waiting for it to
-        // return.
-        // If we get interrupted while executing, we're going to lose our
-        // context, and
-        // won't be able to gather the result at this point.
-        // We set the timeout AFTER the resume, since the resume takes some time
-        // and we
-        // don't want to charge that to the timeout.
+        // We need to call the function synchronously, so spin waiting for
+        // it to return. If we get interrupted while executing, we're
+        // going to lose our context, and won't be able to gather the
+        // result at this point. We set the timeout AFTER the resume,
+        // since the resume takes some time and we don't want to charge
+        // that to the timeout.
       } else {
         if (log)
           log->PutCString("Process::RunThreadPlan(): waiting for next event.");
@@ -5285,8 +5231,8 @@
                 return_value = eExpressionInterrupted;
               } else if (Process::ProcessEventData::GetRestartedFromEvent(
                              event_sp.get())) {
-                // If we were restarted, we just need to go back up to fetch
-                // another event.
+                // If we were restarted, we just need to go back up to
+                // fetch another event.
                 if (log) {
                   log->Printf("Process::RunThreadPlan(): Got a stop and "
                               "restart, so we'll continue waiting.");
@@ -5304,9 +5250,8 @@
 
             case lldb::eStateRunning:
               // This shouldn't really happen, but sometimes we do get two
-              // running events without an
-              // intervening stop, and in that case we should just go back to
-              // waiting for the stop.
+              // running events without an intervening stop, and in that
+              // case we should just go back to waiting for the stop.
               do_resume = false;
               keep_going = true;
               handle_running_event = false;
@@ -5341,10 +5286,10 @@
           break;
         }
       } else {
-        // If we didn't get an event that means we've timed out...
-        // We will interrupt the process here.  Depending on what we were asked
-        // to do we will
-        // either exit, or try with all threads running for the same timeout.
+        // If we didn't get an event that means we've timed out... We will
+        // interrupt the process here.  Depending on what we were asked to
+        // do we will either exit, or try with all threads running for the
+        // same timeout.
 
         if (log) {
           if (options.GetTryAllThreads()) {
@@ -5361,15 +5306,14 @@
                      timeout);
         }
 
-        // It is possible that between the time we issued the Halt, and we get
-        // around to calling Halt the target
-        // could have stopped.  That's fine, Halt will figure that out and send
-        // the appropriate Stopped event.
-        // BUT it is also possible that we stopped & restarted (e.g. hit a
-        // signal with "stop" set to false.)  In
-        // that case, we'll get the stopped & restarted event, and we should go
-        // back to waiting for the Halt's
-        // stopped event.  That's what this while loop does.
+        // It is possible that between the time we issued the Halt, and we
+        // get around to calling Halt the target could have stopped.
+        // That's fine, Halt will figure that out and send the appropriate
+        // Stopped event. BUT it is also possible that we stopped &
+        // restarted (e.g. hit a signal with "stop" set to false.)  In
+        // that case, we'll get the stopped & restarted event, and we
+        // should go back to waiting for the Halt's stopped event.  That's
+        // what this while loop does.
 
         bool back_to_top = true;
         uint32_t try_halt_again = 0;
@@ -5418,8 +5362,8 @@
                 }
 
                 // Between the time we initiated the Halt and the time we
-                // delivered it, the process could have
-                // already finished its job.  Check that here:
+                // delivered it, the process could have already finished
+                // its job.  Check that here:
                 const bool handle_interrupts = false;
                 if (auto result = HandleStoppedEvent(
                         *thread, thread_plan_sp, thread_plan_restorer, event_sp,
@@ -5440,8 +5384,8 @@
                 }
 
                 if (before_first_timeout) {
-                  // Set all the other threads to run, and return to the top of
-                  // the loop, which will continue;
+                  // Set all the other threads to run, and return to the
+                  // top of the loop, which will continue;
                   before_first_timeout = false;
                   thread_plan_sp->SetStopOthers(false);
                   if (log)
@@ -5482,8 +5426,8 @@
       }
     } // END WAIT LOOP
 
-    // If we had to start up a temporary private state thread to run this thread
-    // plan, shut it down now.
+    // If we had to start up a temporary private state thread to run this
+    // thread plan, shut it down now.
     if (backup_private_state_thread.IsJoinable()) {
       StopPrivateStateThread();
       Status error;
@@ -5502,12 +5446,11 @@
       thread->GetStackFrameStatus(s, 0, UINT32_MAX, true, UINT32_MAX);
       log->PutString(s.GetString());
     }
-    // Restore the thread state if we are going to discard the plan execution.
-    // There are three cases where this
-    // could happen:
-    // 1) The execution successfully completed
-    // 2) We hit a breakpoint, and ignore_breakpoints was true
-    // 3) We got some other error, and discard_on_error was true
+    // Restore the thread state if we are going to discard the plan
+    // execution. There are three cases where this could happen: 1) The
+    // execution successfully completed 2) We hit a breakpoint, and
+    // ignore_breakpoints was true 3) We got some other error, and
+    // discard_on_error was true
     bool should_unwind = (return_value == eExpressionInterrupted &&
                           options.DoesUnwindOnError()) ||
                          (return_value == eExpressionHitBreakpoint &&
@@ -5581,8 +5524,8 @@
               else
                 ts.Printf("[ip unknown] ");
 
-              // Show the private stop info here, the public stop info will be
-              // from the last natural stop.
+              // Show the private stop info here, the public stop info
+              // will be from the last natural stop.
               lldb::StopInfoSP stop_info_sp = thread->GetPrivateStopInfo();
               if (stop_info_sp) {
                 const char *stop_desc = stop_info_sp->GetDescription();
@@ -5647,23 +5590,22 @@
     }
 
     // Thread we ran the function in may have gone away because we ran the
-    // target
-    // Check that it's still there, and if it is put it back in the context.
-    // Also restore the
-    // frame in the context if it is still present.
+    // target Check that it's still there, and if it is put it back in the
+    // context. Also restore the frame in the context if it is still
+    // present.
     thread = GetThreadList().FindThreadByIndexID(thread_idx_id, true).get();
     if (thread) {
       exe_ctx.SetFrameSP(thread->GetFrameWithStackID(ctx_frame_id));
     }
 
-    // Also restore the current process'es selected frame & thread, since this
-    // function calling may
-    // be done behind the user's back.
+    // Also restore the current process'es selected frame & thread, since
+    // this function calling may be done behind the user's back.
 
     if (selected_tid != LLDB_INVALID_THREAD_ID) {
       if (GetThreadList().SetSelectedThreadByIndexID(selected_tid) &&
           selected_stack_id.IsValid()) {
-        // We were able to restore the selected thread, now restore the frame:
+        // We were able to restore the selected thread, now restore the
+        // frame:
         std::lock_guard<std::recursive_mutex> guard(GetThreadList().GetMutex());
         StackFrameSP old_frame_sp =
             GetThreadList().GetSelectedThread()->GetFrameWithStackID(
@@ -5675,7 +5617,8 @@
     }
   }
 
-  // If the process exited during the run of the thread plan, notify everyone.
+  // If the process exited during the run of the thread plan, notify
+  // everyone.
 
   if (event_to_broadcast_sp) {
     if (log)
@@ -5748,11 +5691,11 @@
                                 bool stop_format) {
   size_t num_thread_infos_dumped = 0;
 
-  // You can't hold the thread list lock while calling Thread::GetStatus.  That
-  // very well might run code (e.g. if we need it
-  // to get return values or arguments.)  For that to work the process has to be
-  // able to acquire it.  So instead copy the thread
-  // ID's, and look them up one by one:
+  // You can't hold the thread list lock while calling Thread::GetStatus.
+  // That very well might run code (e.g. if we need it to get return
+  // values or arguments.)  For that to work the process has to be able to
+  // acquire it.  So instead copy the thread ID's, and look them up one by
+  // one:
 
   uint32_t num_threads;
   std::vector<lldb::tid_t> thread_id_array;
@@ -5865,12 +5808,12 @@
   DoDidExec();
   CompleteAttach();
   // Flush the process (threads and all stack frames) after running
-  // CompleteAttach()
-  // in case the dynamic loader loaded things in new locations.
+  // CompleteAttach() in case the dynamic loader loaded things in new
+  // locations.
   Flush();
 
-  // After we figure out what was loaded/unloaded in CompleteAttach,
-  // we need to let the target know so it can do any cleanup it needs to.
+  // After we figure out what was loaded/unloaded in CompleteAttach, we
+  // need to let the target know so it can do any cleanup it needs to.
   target.DidExec();
 }
 
@@ -5921,17 +5864,17 @@
     runtime->ModulesDidLoad(module_list);
   }
 
-  // Let any language runtimes we have already created know
-  // about the modules that loaded.
+  // Let any language runtimes we have already created know about the
+  // modules that loaded.
 
-  // Iterate over a copy of this language runtime list in case
-  // the language runtime ModulesDidLoad somehow causes the language
-  // riuntime to be unloaded.
+  // Iterate over a copy of this language runtime list in case the
+  // language runtime ModulesDidLoad somehow causes the language riuntime
+  // to be unloaded.
   LanguageRuntimeCollection language_runtimes(m_language_runtimes);
   for (const auto &pair : language_runtimes) {
-    // We must check language_runtime_sp to make sure it is not
-    // nullptr as we might cache the fact that we didn't have a
-    // language runtime for a language.
+    // We must check language_runtime_sp to make sure it is not nullptr as
+    // we might cache the fact that we didn't have a language runtime for
+    // a language.
     LanguageRuntimeSP language_runtime_sp = pair.second;
     if (language_runtime_sp)
       language_runtime_sp->ModulesDidLoad(module_list);
@@ -6113,7 +6056,8 @@
   do {
     lldb::MemoryRegionInfoSP region_info(new lldb_private::MemoryRegionInfo());
     error = GetMemoryRegionInfo(range_end, *region_info);
-    // GetMemoryRegionInfo should only return an error if it is unimplemented.
+    // GetMemoryRegionInfo should only return an error if it is
+    // unimplemented.
     if (error.Fail()) {
       region_list.clear();
       break;
@@ -6131,9 +6075,10 @@
 Status
 Process::ConfigureStructuredData(const ConstString &type_name,
                                  const StructuredData::ObjectSP &config_sp) {
-  // If you get this, the Process-derived class needs to implement a method
-  // to enable an already-reported asynchronous structured data feature.
-  // See ProcessGDBRemote for an example implementation over gdb-remote.
+  // If you get this, the Process-derived class needs to implement a
+  // method to enable an already-reported asynchronous structured data
+  // feature. See ProcessGDBRemote for an example implementation over gdb-
+  // remote.
   return Status("unimplemented");
 }
 
@@ -6175,8 +6120,8 @@
         return true;
       });
 
-  // For each StructuredDataPlugin, if the plugin handles any of the
-  // types in the supported_type_names, map that type name to that plugin.
+  // For each StructuredDataPlugin, if the plugin handles any of the types
+  // in the supported_type_names, map that type name to that plugin.
   uint32_t plugin_index = 0;
   for (auto create_instance =
            PluginManager::GetStructuredDataPluginCreateCallbackAtIndex(
@@ -6185,8 +6130,8 @@
     // Create the plugin.
     StructuredDataPluginSP plugin_sp = (*create_instance)(*this);
     if (!plugin_sp) {
-      // This plugin doesn't think it can work with the process.
-      // Move on to the next.
+      // This plugin doesn't think it can work with the process. Move on
+      // to the next.
       continue;
     }
 
@@ -6219,7 +6164,8 @@
     return false;
 
   // The contract is this must be a dictionary, so we can look up the
-  // routing key via the top-level 'type' string value within the dictionary.
+  // routing key via the top-level 'type' string value within the
+  // dictionary.
   StructuredData::Dictionary *dictionary = object_sp->GetAsDictionary();
   if (!dictionary)
     return false;
Index: source/Target/ProcessLaunchInfo.cpp
===================================================================
--- source/Target/ProcessLaunchInfo.cpp
+++ source/Target/ProcessLaunchInfo.cpp
@@ -209,9 +209,9 @@
                                             bool default_to_use_pty) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
-  // If nothing for stdin or stdout or stderr was specified, then check the
-  // process for any default
-  // settings that were set with "settings set"
+  // If nothing for stdin or stdout or stderr was specified, then check
+  // the process for any default settings that were set with "settings
+  // set"
   if (GetFileActionForFD(STDIN_FILENO) == nullptr ||
       GetFileActionForFD(STDOUT_FILENO) == nullptr ||
       GetFileActionForFD(STDERR_FILENO) == nullptr) {
@@ -221,8 +221,8 @@
                   __FUNCTION__);
 
     if (m_flags.Test(eLaunchFlagLaunchInTTY)) {
-      // Do nothing, if we are launching in a remote terminal
-      // no file actions should be done at all.
+      // Do nothing, if we are launching in a remote terminal no file
+      // actions should be done at all.
       return;
     }
 
@@ -236,9 +236,8 @@
       AppendSuppressFileAction(STDERR_FILENO, false, true);
     } else {
       // Check for any values that might have gotten set with any of:
-      // (lldb) settings set target.input-path
-      // (lldb) settings set target.output-path
-      // (lldb) settings set target.error-path
+      // (lldb) settings set target.input-path (lldb) settings set target
+      // .output-path (lldb) settings set target.error-path
       FileSpec in_file_spec;
       FileSpec out_file_spec;
       FileSpec err_file_spec;
@@ -295,29 +294,29 @@
 
         int open_flags = O_RDWR | O_NOCTTY;
 #if !defined(_WIN32)
-        // We really shouldn't be specifying platform specific flags
-        // that are intended for a system call in generic code.  But
-        // this will have to do for now.
+        // We really shouldn't be specifying platform specific flags that
+        // are intended for a system call in generic code.  But this will
+        // have to do for now.
         open_flags |= O_CLOEXEC;
 #endif
         if (m_pty->OpenFirstAvailableMaster(open_flags, nullptr, 0)) {
           const FileSpec slave_file_spec{m_pty->GetSlaveName(nullptr, 0),
                                          false};
 
-          // Only use the slave tty if we don't have anything specified for
-          // input and don't have an action for stdin
+          // Only use the slave tty if we don't have anything specified
+          // for input and don't have an action for stdin
           if (!in_file_spec && GetFileActionForFD(STDIN_FILENO) == nullptr) {
             AppendOpenFileAction(STDIN_FILENO, slave_file_spec, true, false);
           }
 
-          // Only use the slave tty if we don't have anything specified for
-          // output and don't have an action for stdout
+          // Only use the slave tty if we don't have anything specified
+          // for output and don't have an action for stdout
           if (!out_file_spec && GetFileActionForFD(STDOUT_FILENO) == nullptr) {
             AppendOpenFileAction(STDOUT_FILENO, slave_file_spec, false, true);
           }
 
-          // Only use the slave tty if we don't have anything specified for
-          // error and don't have an action for stderr
+          // Only use the slave tty if we don't have anything specified
+          // for error and don't have an action for stderr
           if (!err_file_spec && GetFileActionForFD(STDERR_FILENO) == nullptr) {
             AppendOpenFileAction(STDERR_FILENO, slave_file_spec, false, true);
           }
@@ -351,17 +350,17 @@
 
       StreamString shell_command;
       if (will_debug) {
-        // Add a modified PATH environment variable in case argv[0]
-        // is a relative path.
+        // Add a modified PATH environment variable in case argv[0] is a
+        // relative path.
         const char *argv0 = argv[0];
         FileSpec arg_spec(argv0, false);
         if (arg_spec.IsRelative()) {
-          // We have a relative path to our executable which may not work if
-          // we just try to run "a.out" (without it being converted to
+          // We have a relative path to our executable which may not work
+          // if we just try to run "a.out" (without it being converted to
           // "./a.out")
           FileSpec working_dir = GetWorkingDirectory();
-          // Be sure to put quotes around PATH's value in case any paths have
-          // spaces...
+          // Be sure to put quotes around PATH's value in case any paths
+          // have spaces...
           std::string new_path("PATH=\"");
           const size_t empty_path_len = new_path.size();
 
@@ -410,8 +409,8 @@
       }
 
       if (first_arg_is_full_shell_command) {
-        // There should only be one argument that is the shell command itself to
-        // be used as is
+        // There should only be one argument that is the shell command
+        // itself to be used as is
         if (argv[0] && !argv[1])
           shell_command.Printf("%s", argv[0]);
         else
Index: source/Target/RegisterContext.cpp
===================================================================
--- source/Target/RegisterContext.cpp
+++ source/Target/RegisterContext.cpp
@@ -76,9 +76,8 @@
   ExecutionContext exe_ctx(CalculateThread());
 
   // In MIPS, the floating point registers size is depends on FR bit of SR
-  // register.
-  // if SR.FR  == 1 then all floating point registers are 64 bits.
-  // else they are all 32 bits.
+  // register. if SR.FR  == 1 then all floating point registers are 64
+  // bits. else they are all 32 bits.
 
   int expr_result;
   uint32_t addr_size = arch.GetAddressByteSize();
@@ -240,8 +239,8 @@
 
 bool RegisterContext::CopyFromRegisterContext(lldb::RegisterContextSP context) {
   uint32_t num_register_sets = context->GetRegisterSetCount();
-  // We don't know that two threads have the same register context, so require
-  // the threads to be the same.
+  // We don't know that two threads have the same register context, so
+  // require the threads to be the same.
   if (context->GetThreadID() != GetThreadID())
     return false;
 
@@ -261,9 +260,8 @@
         continue;
       RegisterValue reg_value;
 
-      // If we can reconstruct the register from the frame we are copying from,
-      // then do so, otherwise
-      // use the value from frame 0.
+      // If we can reconstruct the register from the frame we are copying
+      // from, then do so, otherwise use the value from frame 0.
       if (context->ReadRegister(reg_info, reg_value)) {
         WriteRegister(reg_info, reg_value);
       } else if (frame_zero_context->ReadRegister(reg_info, reg_value)) {
@@ -355,12 +353,11 @@
       return error;
     }
 
-    // We now have a memory buffer that contains the part or all of the register
-    // value. Set the register value using this memory data.
-    // TODO: we might need to add a parameter to this function in case the byte
-    // order of the memory data doesn't match the process. For now we are
-    // assuming
-    // they are the same.
+    // We now have a memory buffer that contains the part or all of the
+    // register value. Set the register value using this memory data.
+    // TODO: we might need to add a parameter to this function in case the
+    // byte order of the memory data doesn't match the process. For now we
+    // are assuming they are the same.
     reg_value.SetFromMemoryData(reg_info, src, src_len,
                                 process_sp->GetByteOrder(), error);
   } else
@@ -379,10 +376,9 @@
   ProcessSP process_sp(m_thread.GetProcess());
   if (process_sp) {
 
-    // TODO: we might need to add a parameter to this function in case the byte
-    // order of the memory data doesn't match the process. For now we are
-    // assuming
-    // they are the same.
+    // TODO: we might need to add a parameter to this function in case the
+    // byte order of the memory data doesn't match the process. For now we
+    // are assuming they are the same.
 
     const uint32_t bytes_copied = reg_value.GetAsMemoryData(
         reg_info, dst, dst_len, process_sp->GetByteOrder(), error);
@@ -432,8 +428,8 @@
 
 StackFrameSP RegisterContext::CalculateStackFrame() {
   // Register contexts might belong to many frames if we have inlined
-  // functions inside a frame since all inlined functions share the
-  // same registers, so we can't definitively say which frame we come from...
+  // functions inside a frame since all inlined functions share the same
+  // registers, so we can't definitively say which frame we come from...
   return StackFrameSP();
 }
 
Index: source/Target/SectionLoadHistory.cpp
===================================================================
--- source/Target/SectionLoadHistory.cpp
+++ source/Target/SectionLoadHistory.cpp
@@ -42,14 +42,14 @@
                                                 bool read_only) {
   if (!m_stop_id_to_section_load_list.empty()) {
     if (read_only) {
-      // The section load list is for reading data only so we don't need to
-      // create
-      // a new SectionLoadList for the current stop ID, just return the section
-      // load list for the stop ID that is equal to or less than the current
-      // stop ID
+      // The section load list is for reading data only so we don't need
+      // to create a new SectionLoadList for the current stop ID, just
+      // return the section load list for the stop ID that is equal to or
+      // less than the current stop ID
       if (stop_id == eStopIDNow) {
-        // If we are asking for the latest and greatest value, it is always
-        // at the end of our list because that will be the highest stop ID.
+        // If we are asking for the latest and greatest value, it is
+        // always at the end of our list because that will be the highest
+        // stop ID.
         StopIDToSectionLoadList::reverse_iterator rpos =
             m_stop_id_to_section_load_list.rbegin();
         return rpos->second.get();
@@ -69,11 +69,9 @@
       // history
       assert(stop_id != eStopIDNow);
 
-      // We are updating the section load list (not read only), so if the stop
-      // ID
-      // passed in isn't the same as the last stop ID in our collection, then
-      // create
-      // a new node using the current stop ID
+      // We are updating the section load list (not read only), so if the
+      // stop ID passed in isn't the same as the last stop ID in our
+      // collection, then create a new node using the current stop ID
       StopIDToSectionLoadList::iterator pos =
           m_stop_id_to_section_load_list.lower_bound(stop_id);
       if (pos != m_stop_id_to_section_load_list.end() &&
@@ -82,9 +80,9 @@
         return pos->second.get();
       }
 
-      // We must make a new section load list that is based on the last valid
-      // section load list, so here we copy the last section load list and add
-      // a new node for the current stop ID.
+      // We must make a new section load list that is based on the last
+      // valid section load list, so here we copy the last section load
+      // list and add a new node for the current stop ID.
       StopIDToSectionLoadList::reverse_iterator rpos =
           m_stop_id_to_section_load_list.rbegin();
       SectionLoadListSP section_load_list_sp(
Index: source/Target/SectionLoadList.cpp
===================================================================
--- source/Target/SectionLoadList.cpp
+++ source/Target/SectionLoadList.cpp
@@ -93,16 +93,17 @@
     // Fill in the load_addr -> section map
     addr_to_sect_collection::iterator ats_pos = m_addr_to_sect.find(load_addr);
     if (ats_pos != m_addr_to_sect.end()) {
-      // Some sections are ok to overlap, and for others we should warn. When
-      // we have multiple load addresses that correspond to a section, we will
-      // always attribute the section to the be last section that claims it
-      // exists at that address. Sometimes it is ok for more that one section
-      // to be loaded at a specific load address, and other times it isn't.
-      // The "warn_multiple" parameter tells us if we should warn in this case
-      // or not. The DynamicLoader plug-in subclasses should know which
-      // sections should warn and which shouldn't (darwin shared cache modules
-      // all shared the same "__LINKEDIT" sections, so the dynamic loader can
-      // pass false for "warn_multiple").
+      // Some sections are ok to overlap, and for others we should warn.
+      // When we have multiple load addresses that correspond to a
+      // section, we will always attribute the section to the be last
+      // section that claims it exists at that address. Sometimes it is ok
+      // for more that one section to be loaded at a specific load
+      // address, and other times it isn't. The "warn_multiple" parameter
+      // tells us if we should warn in this case or not. The DynamicLoader
+      // plug-in subclasses should know which sections should warn and
+      // which shouldn't (darwin shared cache modules all shared the same
+      // "__LINKEDIT" sections, so the dynamic loader can pass false for
+      // "warn_multiple").
       if (warn_multiple && section != ats_pos->second) {
         ModuleSP module_sp(section->GetModule());
         if (module_sp) {
Index: source/Target/StackFrame.cpp
===================================================================
--- source/Target/StackFrame.cpp
+++ source/Target/StackFrame.cpp
@@ -38,9 +38,9 @@
 using namespace lldb;
 using namespace lldb_private;
 
-// The first bits in the flags are reserved for the SymbolContext::Scope bits
-// so we know if we have tried to look up information in our internal symbol
-// context (m_sc) already.
+// The first bits in the flags are reserved for the SymbolContext::Scope
+// bits so we know if we have tried to look up information in our internal
+// symbol context (m_sc) already.
 #define RESOLVED_FRAME_CODE_ADDR (uint32_t(eSymbolContextEverything + 1))
 #define RESOLVED_FRAME_ID_SYMBOL_SCOPE (RESOLVED_FRAME_CODE_ADDR << 1)
 #define GOT_FRAME_BASE (RESOLVED_FRAME_ID_SYMBOL_SCOPE << 1)
@@ -59,9 +59,9 @@
       m_stop_id(stop_id), m_stop_id_is_valid(stop_id_is_valid),
       m_is_history_frame(is_history_frame), m_variable_list_sp(),
       m_variable_list_value_objects(), m_disassembly(), m_mutex() {
-  // If we don't have a CFA value, use the frame index for our StackID so that
-  // recursive
-  // functions properly aren't confused with one another on a history stack.
+  // If we don't have a CFA value, use the frame index for our StackID so
+  // that recursive functions properly aren't confused with one another on
+  // a history stack.
   if (m_is_history_frame && !m_cfa_is_valid) {
     m_id.SetCFA(m_frame_index);
   }
@@ -136,8 +136,8 @@
 
 StackID &StackFrame::GetStackID() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  // Make sure we have resolved the StackID object's symbol context scope if
-  // we already haven't looked it up.
+  // Make sure we have resolved the StackID object's symbol context scope
+  // if we already haven't looked it up.
 
   if (m_flags.IsClear(RESOLVED_FRAME_ID_SYMBOL_SCOPE)) {
     if (m_id.GetSymbolContextScope()) {
@@ -185,8 +185,9 @@
       !m_frame_code_addr.IsSectionOffset()) {
     m_flags.Set(RESOLVED_FRAME_CODE_ADDR);
 
-    // Resolve the PC into a temporary address because if ResolveLoadAddress
-    // fails to resolve the address, it will clear the address object...
+    // Resolve the PC into a temporary address because if
+    // ResolveLoadAddress fails to resolve the address, it will clear the
+    // address object...
     ThreadSP thread_sp(GetThread());
     if (thread_sp) {
       TargetSP target_sp(thread_sp->CalculateTarget());
@@ -209,7 +210,8 @@
 
 bool StackFrame::ChangePC(addr_t pc) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  // We can't change the pc value of a history stack frame - it is immutable.
+  // We can't change the pc value of a history stack frame - it is
+  // immutable.
   if (m_is_history_frame)
     return false;
   m_frame_code_addr.SetRawAddress(pc);
@@ -247,9 +249,9 @@
   if (m_sc.block) {
     Block *inline_block = m_sc.block->GetContainingInlinedBlock();
     if (inline_block) {
-      // Use the block with the inlined function info
-      // as the frame block we want this frame to have only the variables
-      // for the inlined function and its non-inlined block child blocks.
+      // Use the block with the inlined function info as the frame block
+      // we want this frame to have only the variables for the inlined
+      // function and its non-inlined block child blocks.
       return inline_block;
     } else {
       // This block is not contained within any inlined function blocks
@@ -263,8 +265,8 @@
 //----------------------------------------------------------------------
 // Get the symbol context if we already haven't done so by resolving the
 // PC address as much as possible. This way when we pass around a
-// StackFrame object, everyone will have as much information as
-// possible and no one will ever have to look things up manually.
+// StackFrame object, everyone will have as much information as possible
+// and no one will ever have to look things up manually.
 //----------------------------------------------------------------------
 const SymbolContext &StackFrame::GetSymbolContext(uint32_t resolve_scope) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
@@ -279,8 +281,8 @@
         resolved |= eSymbolContextTarget;
     }
 
-    // Resolve our PC to section offset if we haven't already done so
-    // and if we don't have a module. The resolved address section will
+    // Resolve our PC to section offset if we haven't already done so and
+    // if we don't have a module. The resolved address section will
     // contain the module to which it belongs
     if (!m_sc.module_sp && m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR))
       GetFrameCodeAddress();
@@ -296,10 +298,9 @@
         lookup_addr.SetOffset(offset - 1);
 
       } else {
-        // lookup_addr is the start of a section.  We need
-        // do the math on the actual load address and re-compute
-        // the section.  We're working with a 'noreturn' function
-        // at the end of a section.
+        // lookup_addr is the start of a section.  We need do the math on
+        // the actual load address and re-compute the section.  We're
+        // working with a 'noreturn' function at the end of a section.
         ThreadSP thread_sp(GetThread());
         if (thread_sp) {
           TargetSP target_sp(thread_sp->CalculateTarget());
@@ -367,17 +368,17 @@
       }
 
       if (actual_resolve_scope) {
-        // We might be resolving less information than what is already
-        // in our current symbol context so resolve into a temporary
-        // symbol context "sc" so we don't clear out data we have
-        // already found in "m_sc"
+        // We might be resolving less information than what is already in
+        // our current symbol context so resolve into a temporary symbol
+        // context "sc" so we don't clear out data we have already found
+        // in "m_sc"
         SymbolContext sc;
         // Set flags that indicate what we have tried to resolve
         resolved |= m_sc.module_sp->ResolveSymbolContextForAddress(
             lookup_addr, actual_resolve_scope, sc);
         // Only replace what we didn't already have as we may have
-        // information for an inlined function scope that won't match
-        // what a standard lookup by address would match
+        // information for an inlined function scope that won't match what
+        // a standard lookup by address would match
         if ((resolved & eSymbolContextCompUnit) && m_sc.comp_unit == nullptr)
           m_sc.comp_unit = sc.comp_unit;
         if ((resolved & eSymbolContextFunction) && m_sc.function == nullptr)
@@ -395,23 +396,25 @@
     } else {
       // If we don't have a module, then we can't have the compile unit,
       // function, block, line entry or symbol, so we can safely call
-      // ResolveSymbolContextForAddress with our symbol context member m_sc.
+      // ResolveSymbolContextForAddress with our symbol context member
+      // m_sc.
       if (m_sc.target_sp) {
         resolved |= m_sc.target_sp->GetImages().ResolveSymbolContextForAddress(
             lookup_addr, resolve_scope, m_sc);
       }
     }
 
-    // Update our internal flags so we remember what we have tried to locate so
-    // we don't have to keep trying when more calls to this function are made.
-    // We might have dug up more information that was requested (for example
-    // if we were asked to only get the block, we will have gotten the
-    // compile unit, and function) so set any additional bits that we resolved
+    // Update our internal flags so we remember what we have tried to
+    // locate so we don't have to keep trying when more calls to this
+    // function are made. We might have dug up more information that was
+    // requested (for example if we were asked to only get the block, we
+    // will have gotten the compile unit, and function) so set any
+    // additional bits that we resolved
     m_flags.Set(resolve_scope | resolved);
   }
 
-  // Return the symbol context with everything that was possible to resolve
-  // resolved.
+  // Return the symbol context with everything that was possible to
+  // resolve resolved.
   return m_sc;
 }
 
@@ -514,8 +517,8 @@
   bool address_of = false;
   ValueObjectSP valobj_sp;
   const bool get_file_globals = true;
-  // When looking up a variable for an expression, we need only consider the
-  // variables that are in scope.
+  // When looking up a variable for an expression, we need only consider
+  // the variables that are in scope.
   VariableListSP var_list_sp(GetInScopeVariableList(get_file_globals));
   VariableList *variable_list = var_list_sp.get();
 
@@ -546,8 +549,8 @@
   }
 
   if (!var_sp && (options & eExpressionPathOptionsAllowDirectIVarAccess)) {
-    // Check for direct ivars access which helps us with implicit
-    // access to ivars with the "this->" or "self->"
+    // Check for direct ivars access which helps us with implicit access
+    // to ivars with the "this->" or "self->"
     GetSymbolContext(eSymbolContextFunction | eSymbolContextBlock);
     lldb::LanguageType method_language = eLanguageTypeUnknown;
     bool is_instance_method = false;
@@ -568,8 +571,8 @@
   }
 
   if (!var_sp && (options & eExpressionPathOptionsInspectAnonymousUnions)) {
-    // Check if any anonymous unions are there which contain a variable with
-    // the name we need
+    // Check if any anonymous unions are there which contain a variable
+    // with the name we need
     for (size_t i = 0; i < variable_list->GetSize(); i++) {
       VariableSP variable_sp = variable_list->GetVariableAtIndex(i);
       if (!variable_sp)
@@ -616,21 +619,20 @@
         return ValueObjectSP();
 
       if (no_fragile_ivar) {
-        // Make sure we aren't trying to deref an objective
-        // C ivar if this is not allowed
+        // Make sure we aren't trying to deref an objective C ivar if this
+        // is not allowed
         const uint32_t pointer_type_flags =
             valobj_sp->GetCompilerType().GetTypeInfo(nullptr);
         if ((pointer_type_flags & eTypeIsObjC) &&
             (pointer_type_flags & eTypeIsPointer)) {
-          // This was an objective C object pointer and
-          // it was requested we skip any fragile ivars
-          // so return nothing here
+          // This was an objective C object pointer and it was requested
+          // we skip any fragile ivars so return nothing here
           return ValueObjectSP();
         }
       }
 
-      // If we have a non pointer type with a sythetic value then lets check if
-      // we have an sythetic dereference specified.
+      // If we have a non pointer type with a sythetic value then lets
+      // check if we have an sythetic dereference specified.
       if (!valobj_sp->IsPointerType() && valobj_sp->HasSyntheticValue()) {
         Status deref_error;
         if (valobj_sp->GetCompilerType().IsReferenceType()) {
@@ -659,15 +661,15 @@
       ConstString child_name(var_expr.substr(0, var_expr.find_first_of(".-[")));
 
       if (check_ptr_vs_member) {
-        // We either have a pointer type and need to verify
-        // valobj_sp is a pointer, or we have a member of a
-        // class/union/struct being accessed with the . syntax
-        // and need to verify we don't have a pointer.
+        // We either have a pointer type and need to verify valobj_sp is a
+        // pointer, or we have a member of a class/union/struct being
+        // accessed with the . syntax and need to verify we don't have a
+        // pointer.
         const bool actual_is_ptr = valobj_sp->IsPointerType();
 
         if (actual_is_ptr != expr_is_ptr) {
-          // Incorrect use of "." with a pointer, or "->" with
-          // a class/union/struct instance or reference.
+          // Incorrect use of "." with a pointer, or "->" with a
+          // class/union/struct instance or reference.
           valobj_sp->GetExpressionPath(var_expr_path_strm, false);
           if (actual_is_ptr)
             error.SetErrorStringWithFormat(
@@ -697,10 +699,8 @@
           // No child member with name "child_name"
           if (synthetically_added_instance_object) {
             // We added a "this->" or "self->" to the beginning of the
-            // expression
-            // and this is the first pointer ivar access, so just return
-            // the normal
-            // error
+            // expression and this is the first pointer ivar access, so
+            // just return the normal error
             error.SetErrorStringWithFormat(
                 "no variable or instance variable named '%s' found in "
                 "this frame",
@@ -735,8 +735,8 @@
     } break;
 
     case '[': {
-      // Array member access, or treating pointer as an array
-      // Need at least two brackets and a number
+      // Array member access, or treating pointer as an array Need at
+      // least two brackets and a number
       if (var_expr.size() <= 2) {
         error.SetErrorStringWithFormat(
             "invalid square bracket encountered after \"%s\" in \"%s\"",
@@ -762,8 +762,8 @@
       var_expr = var_expr.drop_front(end_pos + 1);
 
       if (index_expr.consumeInteger(0, child_index)) {
-        // If there was no integer anywhere in the index expression, this is
-        // erroneous expression.
+        // If there was no integer anywhere in the index expression, this
+        // is erroneous expression.
         error.SetErrorStringWithFormat("invalid index expression \"%s\"",
                                        index_expr.str().c_str());
         return ValueObjectSP();
@@ -773,9 +773,9 @@
         // The entire index expression was a single integer.
 
         if (valobj_sp->GetCompilerType().IsPointerToScalarType() && deref) {
-          // what we have is *ptr[low]. the most similar C++ syntax is to deref
-          // ptr and extract bit low out of it. reading array item low would be
-          // done by saying ptr[low], without a deref * sign
+          // what we have is *ptr[low]. the most similar C++ syntax is to
+          // deref ptr and extract bit low out of it. reading array item
+          // low would be done by saying ptr[low], without a deref * sign
           Status error;
           ValueObjectSP temp(valobj_sp->Dereference(error));
           if (error.Fail()) {
@@ -790,11 +790,10 @@
           deref = false;
         } else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() &&
                    deref) {
-          // what we have is *arr[low]. the most similar C++ syntax is
-          // to get arr[0]
-          // (an operation that is equivalent to deref-ing arr)
-          // and extract bit low out of it. reading array item low
-          // would be done by saying arr[low], without a deref * sign
+          // what we have is *arr[low]. the most similar C++ syntax is to
+          // get arr[0] (an operation that is equivalent to deref-ing arr)
+          // and extract bit low out of it. reading array item low would
+          // be done by saying arr[low], without a deref * sign
           Status error;
           ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
           if (error.Fail()) {
@@ -875,8 +874,8 @@
         } else if (valobj_sp->GetCompilerType().IsArrayType(
                        nullptr, nullptr, &is_incomplete_array)) {
           // Pass false to dynamic_value here so we can tell the
-          // difference between
-          // no dynamic value and no member of this type...
+          // difference between no dynamic value and no member of this
+          // type...
           child_valobj_sp = valobj_sp->GetChildAtIndex(child_index, true);
           if (!child_valobj_sp && (is_incomplete_array || !no_synth_child))
             child_valobj_sp =
@@ -946,8 +945,8 @@
           if (dynamic_value_sp)
             child_valobj_sp = dynamic_value_sp;
         }
-        // Break out early from the switch since we were able to find the child
-        // member
+        // Break out early from the switch since we were able to find the
+        // child member
         break;
       }
 
@@ -974,10 +973,10 @@
       }
 
       if (valobj_sp->GetCompilerType().IsPointerToScalarType() && deref) {
-        // what we have is *ptr[low-high]. the most similar C++ syntax is to
-        // deref ptr and extract bits low thru high out of it. reading array
-        // items low thru high would be done by saying ptr[low-high], without
-        // a deref * sign
+        // what we have is *ptr[low-high]. the most similar C++ syntax is
+        // to deref ptr and extract bits low thru high out of it. reading
+        // array items low thru high would be done by saying ptr[low-
+        // high], without a deref * sign
         Status error;
         ValueObjectSP temp(valobj_sp->Dereference(error));
         if (error.Fail()) {
@@ -991,10 +990,11 @@
         valobj_sp = temp;
         deref = false;
       } else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() && deref) {
-        // what we have is *arr[low-high]. the most similar C++ syntax is to get
-        // arr[0] (an operation that is equivalent to deref-ing arr) and extract
-        // bits low thru high out of it. reading array items low thru high would
-        // be done by saying arr[low-high], without a deref * sign
+        // what we have is *arr[low-high]. the most similar C++ syntax is
+        // to get arr[0] (an operation that is equivalent to deref-ing
+        // arr) and extract bits low thru high out of it. reading array
+        // items low thru high would be done by saying arr[low-high],
+        // without a deref * sign
         Status error;
         ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
         if (error.Fail()) {
@@ -1031,8 +1031,8 @@
         if (dynamic_value_sp)
           child_valobj_sp = dynamic_value_sp;
       }
-      // Break out early from the switch since we were able to find the child
-      // member
+      // Break out early from the switch since we were able to find the
+      // child member
       break;
     }
     default:
@@ -1420,8 +1420,8 @@
                                              ValueObjectSP &base,
                                              int64_t offset) {
   // base is a pointer to something
-  // offset is the thing to add to the pointer
-  // We return the most sensible ValueObject for the result of *(base+offset)
+  // offset is the thing to add to the pointer We return the most sensible
+  // ValueObject for the result of *(base+offset)
 
   if (!base->IsPointerOrReferenceType()) {
     return ValueObjectSP();
@@ -1486,8 +1486,9 @@
   //
   // f, a pointer to a struct, is known to be at -0x8(%rbp).
   //
-  // DoGuessValueAt(frame, rdi, 4, dis, vars, 0x22) finds the instruction at +18
-  // that assigns to rdi, and calls itself recursively for that dereference
+  // DoGuessValueAt(frame, rdi, 4, dis, vars, 0x22) finds the instruction
+  // at +18 that assigns to rdi, and calls itself recursively for that
+  // dereference
   //   DoGuessValueAt(frame, rdi, 8, dis, vars, 0x18) finds the instruction at
   //   +14 that assigns to rdi, and calls itself recursively for that
   //   derefernece
@@ -1496,8 +1497,8 @@
   //     Returns a ValueObject for f.  (That's what was stored at rbp-8 at +14)
   //   Returns a ValueObject for *(f+8) or f->b (That's what was stored at rdi+8
   //   at +18)
-  // Returns a ValueObject for *(f->b+4) or f->b->a (That's what was stored at
-  // rdi+4 at +22)
+  // Returns a ValueObject for *(f->b+4) or f->b->a (That's what was
+  // stored at rdi+4 at +22)
 
   // First, check the variable list to see if anything is at the specified
   // location.
@@ -1533,9 +1534,9 @@
 
   for (uint32_t ii = current_inst - 1; ii != (uint32_t)-1; --ii) {
     // This is not an exact algorithm, and it sacrifices accuracy for
-    // generality.  Recognizing "mov" and "ld" instructions –– and which are
-    // their source and destination operands -- is something the disassembler
-    // should do for us.
+    // generality.  Recognizing "mov" and "ld" instructions –– and
+    // which are their source and destination operands -- is something the
+    // disassembler should do for us.
     InstructionSP instruction_sp =
         disassembler.GetInstructionList().GetInstructionAtIndex(ii);
 
Index: source/Target/StackFrameList.cpp
===================================================================
--- source/Target/StackFrameList.cpp
+++ source/Target/StackFrameList.cpp
@@ -51,8 +51,8 @@
 }
 
 StackFrameList::~StackFrameList() {
-  // Call clear since this takes a lock and clears the stack frame list
-  // in case another thread is currently using this stack frame list
+  // Call clear since this takes a lock and clears the stack frame list in
+  // case another thread is currently using this stack frame list
   Clear();
 }
 
@@ -96,12 +96,10 @@
             "ResetCurrentInlinedDepth: Invalidating current inlined depth.\n");
     } else {
       // We only need to do something special about inlined blocks when we
-      // are at the beginning of an inlined function:
-      // FIXME: We probably also have to do something special if the PC is at
-      // the END
-      // of an inlined function, which coincides with the end of either its
-      // containing
-      // function or another inlined function.
+      // are at the beginning of an inlined function: FIXME: We probably
+      // also have to do something special if the PC is at the END of an
+      // inlined function, which coincides with the end of either its
+      // containing function or another inlined function.
 
       lldb::addr_t curr_pc = m_thread.GetRegisterContext()->GetPC();
       Block *block_ptr = m_frames[0]->GetFrameBlock();
@@ -113,20 +111,17 @@
         if (block_ptr->GetRangeContainingAddress(pc_as_address,
                                                  containing_range)) {
           if (pc_as_address == containing_range.GetBaseAddress()) {
-            // If we got here because of a breakpoint hit, then set the inlined
-            // depth depending on where
-            // the breakpoint was set.
-            // If we got here because of a crash, then set the inlined depth to
-            // the deepest most block.
-            // Otherwise, we stopped here naturally as the result of a step, so
-            // set ourselves in the
-            // containing frame of the whole set of nested inlines, so the user
-            // can then "virtually"
-            // step into the frames one by one, or next over the whole mess.
-            // Note: We don't have to handle being somewhere in the middle of
-            // the stack here, since
-            // ResetCurrentInlinedDepth doesn't get called if there is a valid
-            // inlined depth set.
+            // If we got here because of a breakpoint hit, then set the
+            // inlined depth depending on where the breakpoint was set. If
+            // we got here because of a crash, then set the inlined depth
+            // to the deepest most block. Otherwise, we stopped here
+            // naturally as the result of a step, so set ourselves in the
+            // containing frame of the whole set of nested inlines, so the
+            // user can then "virtually" step into the frames one by one,
+            // or next over the whole mess. Note: We don't have to handle
+            // being somewhere in the middle of the stack here, since
+            // ResetCurrentInlinedDepth doesn't get called if there is a
+            // valid inlined depth set.
             StopInfoSP stop_info_sp = m_thread.GetStopInfo();
             if (stop_info_sp) {
               switch (stop_info_sp->GetStopReason()) {
@@ -134,25 +129,22 @@
               case eStopReasonException:
               case eStopReasonExec:
               case eStopReasonSignal:
-                // In all these cases we want to stop in the deepest most frame.
+                // In all these cases we want to stop in the deepest most
+                // frame.
                 m_current_inlined_pc = curr_pc;
                 m_current_inlined_depth = 0;
                 break;
               case eStopReasonBreakpoint: {
-                // FIXME: Figure out what this break point is doing, and set the
-                // inline depth
-                // appropriately.  Be careful to take into account breakpoints
-                // that implement
-                // step over prologue, since that should do the default
-                // calculation.
-                // For now, if the breakpoints corresponding to this hit are all
-                // internal,
-                // I set the stop location to the top of the inlined stack,
-                // since that will make
-                // things like stepping over prologues work right.  But if there
-                // are any non-internal
-                // breakpoints I do to the bottom of the stack, since that was
-                // the old behavior.
+                // FIXME: Figure out what this break point is doing, and
+                // set the inline depth appropriately.  Be careful to take
+                // into account breakpoints that implement step over
+                // prologue, since that should do the default calculation.
+                // For now, if the breakpoints corresponding to this hit
+                // are all internal, I set the stop location to the top of
+                // the inlined stack, since that will make things like
+                // stepping over prologues work right.  But if there are
+                // any non-internal breakpoints I do to the bottom of the
+                // stack, since that was the old behavior.
                 uint32_t bp_site_id = stop_info_sp->GetValue();
                 BreakpointSiteSP bp_site_sp(
                     m_thread.GetProcess()->GetBreakpointSiteList().FindByID(
@@ -176,11 +168,10 @@
               }
                 LLVM_FALLTHROUGH;
               default: {
-                // Otherwise, we should set ourselves at the container of the
-                // inlining, so that the
-                // user can descend into them.
-                // So first we check whether we have more than one inlined block
-                // sharing this PC:
+                // Otherwise, we should set ourselves at the container of
+                // the inlining, so that the user can descend into them.
+                // So first we check whether we have more than one inlined
+                // block sharing this PC:
                 int num_inlined_functions = 0;
 
                 for (Block *container_ptr = block_ptr->GetInlinedParent();
@@ -239,8 +230,8 @@
   if (!m_thread.IsValid())
     return;
 
-  // We've already gotten more frames than asked for, or we've already finished
-  // unwinding, return.
+  // We've already gotten more frames than asked for, or we've already
+  // finished unwinding, return.
   if (m_frames.size() > end_idx || GetAllFramesFetched())
     return;
 
@@ -250,13 +241,12 @@
 #if defined(DEBUG_STACK_FRAMES)
     StreamFile s(stdout, false);
 #endif
-    // If we are hiding some frames from the outside world, we need to add those
-    // onto the total count of
-    // frames to fetch.  However, we don't need to do that if end_idx is 0 since
-    // in that case we always
-    // get the first concrete frame and all the inlined frames below it...  And
-    // of course, if end_idx is
-    // UINT32_MAX that means get all, so just do that...
+    // If we are hiding some frames from the outside world, we need to add
+    // those onto the total count of frames to fetch.  However, we don't
+    // need to do that if end_idx is 0 since in that case we always get
+    // the first concrete frame and all the inlined frames below it...
+    // And of course, if end_idx is UINT32_MAX that means get all, so just
+    // do that...
 
     uint32_t inlined_depth = 0;
     if (end_idx > 0 && end_idx != UINT32_MAX) {
@@ -273,18 +263,18 @@
       lldb::addr_t pc = LLDB_INVALID_ADDRESS;
       lldb::addr_t cfa = LLDB_INVALID_ADDRESS;
       if (idx == 0) {
-        // We might have already created frame zero, only create it
-        // if we need to
+        // We might have already created frame zero, only create it if we
+        // need to
         if (m_frames.empty()) {
           RegisterContextSP reg_ctx_sp(m_thread.GetRegisterContext());
 
           if (reg_ctx_sp) {
             const bool success =
                 unwinder && unwinder->GetFrameInfoAtIndex(idx, cfa, pc);
-            // There shouldn't be any way not to get the frame info for frame 0.
-            // But if the unwinder can't make one, lets make one by hand with
-            // the
-            // SP as the CFA and see if that gets any further.
+            // There shouldn't be any way not to get the frame info for
+            // frame 0. But if the unwinder can't make one, lets make one
+            // by hand with the SP as the CFA and see if that gets any
+            // further.
             if (!success) {
               cfa = reg_ctx_sp->GetSP();
               pc = reg_ctx_sp->GetPC();
@@ -323,18 +313,17 @@
       if (unwind_block) {
         Address curr_frame_address(unwind_frame_sp->GetFrameCodeAddress());
         TargetSP target_sp = m_thread.CalculateTarget();
-        // Be sure to adjust the frame address to match the address
-        // that was used to lookup the symbol context above. If we are
-        // in the first concrete frame, then we lookup using the current
-        // address, else we decrement the address by one to get the correct
+        // Be sure to adjust the frame address to match the address that
+        // was used to lookup the symbol context above. If we are in the
+        // first concrete frame, then we lookup using the current address,
+        // else we decrement the address by one to get the correct
         // location.
         if (idx > 0) {
           if (curr_frame_address.GetOffset() == 0) {
-            // If curr_frame_address points to the first address in a section
-            // then after
-            // adjustment it will point to an other section. In that case
-            // resolve the
-            // address again to the correct section plus offset form.
+            // If curr_frame_address points to the first address in a
+            // section then after adjustment it will point to an other
+            // section. In that case resolve the address again to the
+            // correct section plus offset form.
             addr_t load_addr = curr_frame_address.GetOpcodeLoadAddress(
                 target_sp.get(), eAddressClassCode);
             curr_frame_address.SetOpcodeLoadAddress(
@@ -362,15 +351,18 @@
       }
     } while (m_frames.size() - 1 < end_idx);
 
-    // Don't try to merge till you've calculated all the frames in this stack.
+    // Don't try to merge till you've calculated all the frames in this
+    // stack.
     if (GetAllFramesFetched() && m_prev_frames_sp) {
       StackFrameList *prev_frames = m_prev_frames_sp.get();
       StackFrameList *curr_frames = this;
 
-// curr_frames->m_current_inlined_depth = prev_frames->m_current_inlined_depth;
-// curr_frames->m_current_inlined_pc = prev_frames->m_current_inlined_pc;
-// printf ("GetFramesUpTo: Copying current inlined depth: %d 0x%" PRIx64 ".\n",
-// curr_frames->m_current_inlined_depth, curr_frames->m_current_inlined_pc);
+// curr_frames->m_current_inlined_depth =
+// prev_frames->m_current_inlined_depth; curr_frames->m_current_inlined_pc
+// = prev_frames->m_current_inlined_pc; printf ("GetFramesUpTo: Copying
+// current inlined depth: %d 0x%" PRIx64 ".\n",
+// curr_frames->m_current_inlined_depth,
+// curr_frames->m_current_inlined_pc);
 
 #if defined(DEBUG_STACK_FRAMES)
       s.PutCString("\nprev_frames:\n");
@@ -414,8 +406,8 @@
           break;
 
         prev_frame->UpdatePreviousFrameFromCurrentFrame(*curr_frame);
-        // Now copy the fixed up previous frame into the current frames
-        // so the pointer doesn't change
+        // Now copy the fixed up previous frame into the current frames so
+        // the pointer doesn't change
         m_frames[curr_frame_idx] = prev_frame_sp;
 // curr_frame->UpdateCurrentFrameFromPreviousFrame (*prev_frame);
 
@@ -495,14 +487,14 @@
   if (frame_sp)
     return frame_sp;
 
-  // GetFramesUpTo will fill m_frames with as many frames as you asked for,
-  // if there are that many.  If there weren't then you asked for too many
-  // frames.
+  // GetFramesUpTo will fill m_frames with as many frames as you asked
+  // for, if there are that many.  If there weren't then you asked for too
+  // many frames.
   GetFramesUpTo(idx);
   if (idx < m_frames.size()) {
     if (m_show_inlined_frames) {
-      // When inline frames are enabled we actually create all the frames in
-      // GetFramesUpTo.
+      // When inline frames are enabled we actually create all the frames
+      // in GetFramesUpTo.
       frame_sp = m_frames[idx];
     } else {
       Unwind *unwinder = m_thread.GetUnwinder();
@@ -519,12 +511,12 @@
           Function *function =
               frame_sp->GetSymbolContext(eSymbolContextFunction).function;
           if (function) {
-            // When we aren't showing inline functions we always use
-            // the top most function block as the scope.
+            // When we aren't showing inline functions we always use the
+            // top most function block as the scope.
             frame_sp->SetSymbolContextScope(&function->GetBlock(false));
           } else {
-            // Set the symbol scope from the symbol regardless if it is nullptr
-            // or valid.
+            // Set the symbol scope from the symbol regardless if it is
+            // nullptr or valid.
             frame_sp->SetSymbolContextScope(
                 frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol);
           }
@@ -533,11 +525,10 @@
       }
     }
   } else if (original_idx == 0) {
-    // There should ALWAYS be a frame at index 0.  If something went wrong with
-    // the CurrentInlinedDepth such that
-    // there weren't as many frames as we thought taking that into account, then
-    // reset the current inlined depth
-    // and return the real zeroth frame.
+    // There should ALWAYS be a frame at index 0.  If something went wrong
+    // with the CurrentInlinedDepth such that there weren't as many frames
+    // as we thought taking that into account, then reset the current
+    // inlined depth and return the real zeroth frame.
     if (m_frames.empty()) {
       // Why do we have a thread with zero frames, that should not ever
       // happen...
@@ -553,12 +544,13 @@
 
 StackFrameSP
 StackFrameList::GetFrameWithConcreteFrameIndex(uint32_t unwind_idx) {
-  // First try assuming the unwind index is the same as the frame index. The
-  // unwind index is always greater than or equal to the frame index, so it
-  // is a good place to start. If we have inlined frames we might have 5
-  // concrete frames (frame unwind indexes go from 0-4), but we might have 15
-  // frames after we make all the inlined frames. Most of the time the unwind
-  // frame index (or the concrete frame index) is the same as the frame index.
+  // First try assuming the unwind index is the same as the frame index.
+  // The unwind index is always greater than or equal to the frame index,
+  // so it is a good place to start. If we have inlined frames we might
+  // have 5 concrete frames (frame unwind indexes go from 0-4), but we
+  // might have 15 frames after we make all the inlined frames. Most of
+  // the time the unwind frame index (or the concrete frame index) is the
+  // same as the frame index.
   uint32_t frame_idx = unwind_idx;
   StackFrameSP frame_sp(GetFrameAtIndex(frame_idx));
   while (frame_sp) {
@@ -663,8 +655,8 @@
   }
 }
 
-// The thread has been run, reset the number stack frames to zero so we can
-// determine how many frames we have lazily.
+// The thread has been run, reset the number stack frames to zero so we
+// can determine how many frames we have lazily.
 void StackFrameList::Clear() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   m_frames.clear();
@@ -719,9 +711,9 @@
 #if defined(DEBUG_STACK_FRAMES)
     s.PutCString("No previous frames, so use current frames...\n");
 #endif
-    // We either don't have any previous frames, or since we have more than
-    // one current frames it means we have all the frames and can safely
-    // replace our previous frames.
+    // We either don't have any previous frames, or since we have more
+    // than one current frames it means we have all the frames and can
+    // safely replace our previous frames.
     prev_sp.reset(curr_ap.release());
     return;
   }
@@ -733,8 +725,8 @@
     s.PutCString(
         "We have more than one current frame, so use current frames...\n");
 #endif
-    // We have more than one current frames it means we have all the frames
-    // and can safely replace our previous frames.
+    // We have more than one current frames it means we have all the
+    // frames and can safely replace our previous frames.
     prev_sp.reset(curr_ap.release());
 
 #if defined(DEBUG_STACK_FRAMES)
Index: source/Target/StackID.cpp
===================================================================
--- source/Target/StackID.cpp
+++ source/Target/StackID.cpp
@@ -66,15 +66,14 @@
   const lldb::addr_t lhs_cfa = lhs.GetCallFrameAddress();
   const lldb::addr_t rhs_cfa = rhs.GetCallFrameAddress();
 
-  // FIXME: We are assuming that the stacks grow downward in memory.  That's not
-  // necessary, but true on
-  // all the machines we care about at present.  If this changes, we'll have to
-  // deal with that.  The ABI is the
-  // agent who knows this ordering, but the StackID has no access to the ABI.
-  // The most straightforward way
-  // to handle this is to add a "m_grows_downward" bool to the StackID, and set
-  // it in the constructor.
-  // But I'm not going to waste a bool per StackID on this till we need it.
+  // FIXME: We are assuming that the stacks grow downward in memory.
+  // That's not necessary, but true on all the machines we care about at
+  // present.  If this changes, we'll have to deal with that.  The ABI is
+  // the agent who knows this ordering, but the StackID has no access to
+  // the ABI. The most straightforward way to handle this is to add a
+  // "m_grows_downward" bool to the StackID, and set it in the
+  // constructor. But I'm not going to waste a bool per StackID on this
+  // till we need it.
 
   if (lhs_cfa != rhs_cfa)
     return lhs_cfa < rhs_cfa;
Index: source/Target/StopInfo.cpp
===================================================================
--- source/Target/StopInfo.cpp
+++ source/Target/StopInfo.cpp
@@ -63,14 +63,11 @@
       return true;
     } else if (ret_type == eStateStopped) {
       // This is a little tricky.  We want to count "run and stopped again
-      // before you could
-      // ask this question as a "TRUE" answer to HasTargetRunSinceMe.  But we
-      // don't want to
-      // include any running of the target done for expressions.  So we track
-      // both resumes,
-      // and resumes caused by expressions, and check if there are any resumes
-      // NOT caused
-      // by expressions.
+      // before you could ask this question as a "TRUE" answer to
+      // HasTargetRunSinceMe.  But we don't want to include any running of
+      // the target done for expressions.  So we track both resumes, and
+      // resumes caused by expressions, and check if there are any resumes
+      // NOT caused by expressions.
 
       uint32_t curr_resume_id = thread_sp->GetProcess()->GetResumeID();
       uint32_t last_user_expression_id =
@@ -199,8 +196,8 @@
         if (bp_site_sp) {
           StreamString strm;
           // If we have just hit an internal breakpoint, and it has a kind
-          // description, print that instead of the
-          // full breakpoint printing:
+          // description, print that instead of the full breakpoint
+          // printing:
           if (bp_site_sp->IsInternal()) {
             size_t num_owners = bp_site_sp->GetNumberOfOwners();
             for (size_t idx = 0; idx < num_owners; idx++) {
@@ -258,9 +255,9 @@
 
 protected:
   bool ShouldStop(Event *event_ptr) override {
-    // This just reports the work done by PerformAction or the synchronous stop.
-    // It should
-    // only ever get called after they have had a chance to run.
+    // This just reports the work done by PerformAction or the synchronous
+    // stop. It should only ever get called after they have had a chance
+    // to run.
     assert(m_should_stop_is_valid);
     return m_should_stop;
   }
@@ -278,7 +275,8 @@
           LIBLLDB_LOG_BREAKPOINTS | LIBLLDB_LOG_STEP);
 
       if (!thread_sp->IsValid()) {
-        // This shouldn't ever happen, but just in case, don't do more harm.
+        // This shouldn't ever happen, but just in case, don't do more
+        // harm.
         if (log) {
           log->Printf("PerformAction got called with an invalid thread.");
         }
@@ -292,55 +290,49 @@
       std::unordered_set<break_id_t> precondition_breakpoints;
 
       if (bp_site_sp) {
-        // Let's copy the owners list out of the site and store them in a local
-        // list.  That way if
-        // one of the breakpoint actions changes the site, then we won't be
-        // operating on a bad list.
+        // Let's copy the owners list out of the site and store them in a
+        // local list.  That way if one of the breakpoint actions changes
+        // the site, then we won't be operating on a bad list.
         BreakpointLocationCollection site_locations;
         size_t num_owners = bp_site_sp->CopyOwnersList(site_locations);
 
         if (num_owners == 0) {
           m_should_stop = true;
         } else {
-          // We go through each location, and test first its precondition - this
-          // overrides everything.  Note,
-          // we only do this once per breakpoint - not once per location...
-          // Then check the condition.  If the condition says to stop,
-          // then we run the callback for that location.  If that callback says
-          // to stop as well, then
-          // we set m_should_stop to true; we are going to stop.
-          // But we still want to give all the breakpoints whose conditions say
-          // we are going to stop a
-          // chance to run their callbacks.
-          // Of course if any callback restarts the target by putting "continue"
-          // in the callback, then
-          // we're going to restart, without running the rest of the callbacks.
-          // And in this case we will
-          // end up not stopping even if another location said we should stop.
-          // But that's better than not
+          // We go through each location, and test first its precondition
+          // - this overrides everything.  Note, we only do this once per
+          // breakpoint - not once per location... Then check the
+          // condition.  If the condition says to stop, then we run the
+          // callback for that location.  If that callback says to stop as
+          // well, then we set m_should_stop to true; we are going to
+          // stop. But we still want to give all the breakpoints whose
+          // conditions say we are going to stop a chance to run their
+          // callbacks. Of course if any callback restarts the target by
+          // putting "continue" in the callback, then we're going to
+          // restart, without running the rest of the callbacks. And in
+          // this case we will end up not stopping even if another
+          // location said we should stop. But that's better than not
           // running all the callbacks.
 
           m_should_stop = false;
 
-          // We don't select threads as we go through them testing breakpoint
-          // conditions and running commands.
-          // So we need to set the thread for expression evaluation here:
+          // We don't select threads as we go through them testing
+          // breakpoint conditions and running commands. So we need to set
+          // the thread for expression evaluation here:
           ThreadList::ExpressionExecutionThreadPusher thread_pusher(thread_sp);
 
           ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
           Process *process = exe_ctx.GetProcessPtr();
           if (process->GetModIDRef().IsLastResumeForUserExpression()) {
-            // If we are in the middle of evaluating an expression, don't run
-            // asynchronous breakpoint commands or
-            // expressions.  That could lead to infinite recursion if the
-            // command or condition re-calls the function
-            // with this breakpoint.
-            // TODO: We can keep a list of the breakpoints we've seen while
-            // running expressions in the nested
-            // PerformAction calls that can arise when the action runs a
-            // function that hits another breakpoint,
-            // and only stop running commands when we see the same breakpoint
-            // hit a second time.
+            // If we are in the middle of evaluating an expression, don't
+            // run asynchronous breakpoint commands or expressions.  That
+            // could lead to infinite recursion if the command or
+            // condition re-calls the function with this breakpoint. TODO:
+            // We can keep a list of the breakpoints we've seen while
+            // running expressions in the nested PerformAction calls that
+            // can arise when the action runs a function that hits another
+            // breakpoint, and only stop running commands when we see the
+            // same breakpoint hit a second time.
 
             m_should_stop_is_valid = true;
             if (log)
@@ -377,12 +369,11 @@
           StoppointCallbackContext context(event_ptr, exe_ctx, false);
 
           // For safety's sake let's also grab an extra reference to the
-          // breakpoint owners of the locations we're
-          // going to examine, since the locations are going to have to get back
-          // to their breakpoints, and the
-          // locations don't keep their owners alive.  I'm just sticking the
-          // BreakpointSP's in a vector since
-          // I'm only using it to locally increment their retain counts.
+          // breakpoint owners of the locations we're going to examine,
+          // since the locations are going to have to get back to their
+          // breakpoints, and the locations don't keep their owners alive.
+          // I'm just sticking the BreakpointSP's in a vector since I'm
+          // only using it to locally increment their retain counts.
 
           std::vector<lldb::BreakpointSP> location_owners;
 
@@ -397,15 +388,15 @@
             if (log) {
               bp_loc_sp->GetDescription(&loc_desc, eDescriptionLevelBrief);
             }
-            // If another action disabled this breakpoint or its location, then
-            // don't run the actions.
+            // If another action disabled this breakpoint or its location,
+            // then don't run the actions.
             if (!bp_loc_sp->IsEnabled() ||
                 !bp_loc_sp->GetBreakpoint().IsEnabled())
               continue;
 
-            // The breakpoint site may have many locations associated with it,
-            // not all of them valid for
-            // this thread.  Skip the ones that aren't:
+            // The breakpoint site may have many locations associated with
+            // it, not all of them valid for this thread.  Skip the ones
+            // that aren't:
             if (!bp_loc_sp->ValidForThisThread(thread_sp.get())) {
               if (log) {
                 log->Printf("Breakpoint %s hit on thread 0x%llx but it was not "
@@ -418,9 +409,8 @@
 
             internal_breakpoint = bp_loc_sp->GetBreakpoint().IsInternal();
             
-            // First run the precondition, but since the precondition is per
-            // breakpoint, only run it once
-            // per breakpoint.
+            // First run the precondition, but since the precondition is
+            // per breakpoint, only run it once per breakpoint.
             std::pair<std::unordered_set<break_id_t>::iterator, bool> result =
                 precondition_breakpoints.insert(
                     bp_loc_sp->GetBreakpoint().GetID());
@@ -433,9 +423,9 @@
               continue;
 
             // Next run the condition for the breakpoint.  If that says we
-            // should stop, then we'll run
-            // the callback for the breakpoint.  If the callback says we
-            // shouldn't stop that will win.
+            // should stop, then we'll run the callback for the
+            // breakpoint.  If the callback says we shouldn't stop that
+            // will win.
 
             if (bp_loc_sp->GetConditionText() != nullptr) {
               Status condition_error;
@@ -469,30 +459,30 @@
                               condition_says_stop);
                 }
                 if (!condition_says_stop) {
-                  // We don't want to increment the hit count of breakpoints if
-                  // the condition fails.
-                  // We've already bumped it by the time we get here, so undo
-                  // the bump:
+                  // We don't want to increment the hit count of
+                  // breakpoints if the condition fails. We've already
+                  // bumped it by the time we get here, so undo the bump:
                   bp_loc_sp->UndoBumpHitCount();
                   continue;
                 }
               }
             }
 
-            // Check the auto-continue bit on the location, do this before the
-            // callback since it may change this, but that would be for the
-            // NEXT hit.  Note, you might think you could check auto-continue
-            // before the condition, and not evaluate the condition if it says
-            // to continue.  But failing the condition means the breakpoint was
-            // effectively NOT HIT.  So these two states are different.
+            // Check the auto-continue bit on the location, do this before
+            // the callback since it may change this, but that would be
+            // for the NEXT hit.  Note, you might think you could check
+            // auto-continue before the condition, and not evaluate the
+            // condition if it says to continue.  But failing the
+            // condition means the breakpoint was effectively NOT HIT.  So
+            // these two states are different.
             bool auto_continue_says_stop = true;
             if (bp_loc_sp->IsAutoContinue())
             {
               if (log)
                 log->Printf("Continuing breakpoint %s as AutoContinue was set.",
                             loc_desc.GetData());
-              // We want this stop reported, so you will know we auto-continued
-              // but only for external breakpoints:
+              // We want this stop reported, so you will know we auto-
+              // continued but only for external breakpoints:
               if (!internal_breakpoint)
                 thread_sp->SetShouldReportStop(eVoteYes);
               auto_continue_says_stop = false;
@@ -500,11 +490,10 @@
 
             bool callback_says_stop = true;
 
-            // FIXME: For now the callbacks have to run in async mode - the
-            // first time we restart we need
-            // to get out of there.  So set it here.
-            // When we figure out how to nest breakpoint hits then this will
-            // change.
+            // FIXME: For now the callbacks have to run in async mode -
+            // the first time we restart we need to get out of there.  So
+            // set it here. When we figure out how to nest breakpoint hits
+            // then this will change.
 
             Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger();
             bool old_async = debugger.GetAsyncExecution();
@@ -517,24 +506,24 @@
             if (callback_says_stop && auto_continue_says_stop)
               m_should_stop = true;
                   
-            // If we are going to stop for this breakpoint, then remove the
-            // breakpoint.
+            // If we are going to stop for this breakpoint, then remove
+            // the breakpoint.
             if (callback_says_stop && bp_loc_sp &&
                 bp_loc_sp->GetBreakpoint().IsOneShot()) {
               thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID(
                   bp_loc_sp->GetBreakpoint().GetID());
             }
-            // Also make sure that the callback hasn't continued the target.
-            // If it did, when we'll set m_should_start to false and get out of
-            // here.
+            // Also make sure that the callback hasn't continued the
+            // target. If it did, when we'll set m_should_start to false
+            // and get out of here.
             if (HasTargetRunSinceMe()) {
               m_should_stop = false;
               break;
             }
           }
         }
-        // We've figured out what this stop wants to do, so mark it as valid so
-        // we don't compute it again.
+        // We've figured out what this stop wants to do, so mark it as
+        // valid so we don't compute it again.
         m_should_stop_is_valid = true;
       } else {
         m_should_stop = true;
@@ -551,13 +540,13 @@
       if ((m_should_stop == false || internal_breakpoint)
           && thread_sp->CompletedPlanOverridesBreakpoint()) {
         
-        // Override should_stop decision when we have
-        // completed step plan additionally to the breakpoint
+        // Override should_stop decision when we have completed step plan
+        // additionally to the breakpoint
         m_should_stop = true;
         
-        // Here we clean the preset stop info so the next
-        // GetStopInfo call will find the appropriate stop info,
-        // which should be the stop info related to the completed plan
+        // Here we clean the preset stop info so the next GetStopInfo call
+        // will find the appropriate stop info, which should be the stop
+        // info related to the completed plan
         thread_sp->ResetStopInfo();
       }
 
@@ -572,12 +561,12 @@
   bool m_should_stop_is_valid;
   bool m_should_perform_action; // Since we are trying to preserve the "state"
                                 // of the system even if we run functions
-  // etc. behind the users backs, we need to make sure we only REALLY perform
-  // the action once.
+  // etc. behind the users backs, we need to make sure we only REALLY
+  // perform the action once.
   lldb::addr_t m_address; // We use this to capture the breakpoint site address
                           // when we create the StopInfo,
-  // in case somebody deletes it between the time the StopInfo is made and the
-  // description is asked for.
+  // in case somebody deletes it between the time the StopInfo is made and
+  // the description is asked for.
   lldb::break_id_t m_break_id;
   bool m_was_one_shot;
 };
@@ -588,8 +577,8 @@
 
 class StopInfoWatchpoint : public StopInfo {
 public:
-  // Make sure watchpoint is properly disabled and subsequently enabled while
-  // performing watchpoint actions.
+  // Make sure watchpoint is properly disabled and subsequently enabled
+  // while performing watchpoint actions.
   class WatchpointSentry {
   public:
     WatchpointSentry(ProcessSP p_sp, WatchpointSP w_sp) : process_sp(p_sp), 
@@ -653,7 +642,8 @@
 protected:
   bool ShouldStopSynchronous(Event *event_ptr) override {
     // ShouldStop() method is idempotent and should not affect hit count.
-    // See Process::RunPrivateStateThread()->Process()->HandlePrivateEvent()
+    // See
+    // Process::RunPrivateStateThread()->Process()->HandlePrivateEvent()
     // -->Process()::ShouldBroadcastEvent()->ThreadList::ShouldStop()->
     // Thread::ShouldStop()->ThreadPlanBase::ShouldStop()->
     // StopInfoWatchpoint::ShouldStop() and
@@ -689,18 +679,18 @@
   }
 
   bool ShouldStop(Event *event_ptr) override {
-    // This just reports the work done by PerformAction or the synchronous stop.
-    // It should
-    // only ever get called after they have had a chance to run.
+    // This just reports the work done by PerformAction or the synchronous
+    // stop. It should only ever get called after they have had a chance
+    // to run.
     assert(m_should_stop_is_valid);
     return m_should_stop;
   }
 
   void PerformAction(Event *event_ptr) override {
     Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS);
-    // We're going to calculate if we should stop or not in some way during the
-    // course of
-    // this code.  Also by default we're going to stop, so set that here.
+    // We're going to calculate if we should stop or not in some way
+    // during the course of this code.  Also by default we're going to
+    // stop, so set that here.
     m_should_stop = true;
     
 
@@ -716,10 +706,9 @@
 
         {
           // check if this process is running on an architecture where
-          // watchpoints trigger
-          // before the associated instruction runs. if so, disable the WP,
-          // single-step and then
-          // re-enable the watchpoint
+          // watchpoints trigger before the associated instruction runs.
+          // if so, disable the WP, single-step and then re-enable the
+          // watchpoint
           if (process_sp) {
             uint32_t num;
             bool wp_triggers_after;
@@ -727,10 +716,9 @@
             if (process_sp->GetWatchpointSupportInfo(num, wp_triggers_after)
                     .Success()) {
               if (!wp_triggers_after) {
-                // We need to preserve the watch_index before watchpoint 
+                // We need to preserve the watch_index before watchpoint
                 // is disable. Since Watchpoint::SetEnabled will clear the
-                // watch index.
-                // This will fix TestWatchpointIter failure
+                // watch index. This will fix TestWatchpointIter failure
                 Watchpoint *wp = wp_sp.get();
                 uint32_t watch_index = wp->GetHardwareIndex();
                 process_sp->DisableWatchpoint(wp, false);
@@ -758,9 +746,9 @@
           }
         }
 
-        // This sentry object makes sure the current watchpoint is disabled
-        // while performing watchpoint actions,
-        // and it is then enabled after we are finished.
+        // This sentry object makes sure the current watchpoint is
+        // disabled while performing watchpoint actions, and it is then
+        // enabled after we are finished.
         WatchpointSentry sentry(process_sp, wp_sp);
 
         /*
@@ -786,19 +774,16 @@
           }
         }
 
-        // TODO: This condition should be checked in the synchronous part of the
-        // watchpoint code
-        // (Watchpoint::ShouldStop), so that we avoid pulling an event even if
-        // the watchpoint fails
-        // the ignore count condition. It is moved here temporarily, because for
-        // archs with
-        // watchpoint_exceptions_received=before, the code in the previous lines
-        // takes care of moving
-        // the inferior to next PC. We have to check the ignore count condition
-        // after this is done,
-        // otherwise we will hit same watchpoint multiple times until we pass
-        // ignore condition, but we
-        // won't actually be ignoring them.
+        // TODO: This condition should be checked in the synchronous part
+        // of the watchpoint code (Watchpoint::ShouldStop), so that we
+        // avoid pulling an event even if the watchpoint fails the ignore
+        // count condition. It is moved here temporarily, because for
+        // archs with watchpoint_exceptions_received=before, the code in
+        // the previous lines takes care of moving the inferior to next
+        // PC. We have to check the ignore count condition after this is
+        // done, otherwise we will hit same watchpoint multiple times
+        // until we pass ignore condition, but we won't actually be
+        // ignoring them.
         if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount())
           m_should_stop = false;
 
@@ -823,10 +808,11 @@
               Scalar scalar_value;
               if (result_value_sp->ResolveValue(scalar_value)) {
                 if (scalar_value.ULongLong(1) == 0) {
-                  // We have been vetoed.  This takes precedence over querying
-                  // the watchpoint whether it should stop (aka ignore count and
-                  // friends).  See also StopInfoWatchpoint::ShouldStop() as
-                  // well as Process::ProcessEventData::DoOnRemoval().
+                  // We have been vetoed.  This takes precedence over
+                  // querying the watchpoint whether it should stop (aka
+                  // ignore count and friends).  See also
+                  // StopInfoWatchpoint::ShouldStop() as well as
+                  // Process::ProcessEventData::DoOnRemoval().
                   m_should_stop = false;
                 } else
                   m_should_stop = true;
@@ -860,14 +846,13 @@
           }
         }
 
-        // If the condition says to stop, we run the callback to further decide
-        // whether to stop.
+        // If the condition says to stop, we run the callback to further
+        // decide whether to stop.
         if (m_should_stop) {
-            // FIXME: For now the callbacks have to run in async mode - the
-            // first time we restart we need
-            // to get out of there.  So set it here.
-            // When we figure out how to nest watchpoint hits then this will
-            // change.
+            // FIXME: For now the callbacks have to run in async mode -
+            // the first time we restart we need to get out of there.  So
+            // set it here. When we figure out how to nest watchpoint hits
+            // then this will change.
 
           bool old_async = debugger.GetAsyncExecution();
           debugger.SetAsyncExecution(true);
@@ -878,8 +863,8 @@
           debugger.SetAsyncExecution(old_async);
           
           // Also make sure that the callback hasn't continued the target.
-          // If it did, when we'll set m_should_stop to false and get out of
-          // here.
+          // If it did, when we'll set m_should_stop to false and get out
+          // of here.
           if (HasTargetRunSinceMe())
             m_should_stop = false;
 
@@ -888,7 +873,8 @@
             m_should_stop = false;
           }
         }
-        // Finally, if we are going to stop, print out the new & old values:
+        // Finally, if we are going to stop, print out the new & old
+        // values:
         if (m_should_stop) {
           wp_sp->CaptureWatchedValue(exe_ctx);
 
Index: source/Target/StructuredDataPlugin.cpp
===================================================================
--- source/Target/StructuredDataPlugin.cpp
+++ source/Target/StructuredDataPlugin.cpp
@@ -34,8 +34,8 @@
 StructuredDataPlugin::~StructuredDataPlugin() {}
 
 bool StructuredDataPlugin::GetEnabled(const ConstString &type_name) const {
-  // By default, plugins are always enabled.  Plugin authors should override
-  // this if there is an enabled/disabled state for their plugin.
+  // By default, plugins are always enabled.  Plugin authors should
+  // override this if there is an enabled/disabled state for their plugin.
   return true;
 }
 
Index: source/Target/Target.cpp
===================================================================
--- source/Target/Target.cpp
+++ source/Target/Target.cpp
@@ -356,7 +356,8 @@
   }
   SearchFilterSP filter_sp;
   if (check_inlines == eLazyBoolNo) {
-    // Not checking for inlines, we are looking only for matching compile units
+    // Not checking for inlines, we are looking only for matching compile
+    // units
     FileSpecList compile_unit_list;
     compile_unit_list.Append(remapped_file);
     filter_sp = GetSearchFilterForModuleAndCUList(containingModules,
@@ -379,7 +380,8 @@
                                       bool hardware) {
   Address so_addr;
 
-  // Check for any reason we want to move this breakpoint to other address.
+  // Check for any reason we want to move this breakpoint to other
+  // address.
   addr = GetBreakableLoadAddress(addr);
 
   // Attempt to resolve our load address if possible, though it is ok if
@@ -536,9 +538,9 @@
 
   SearchFilterSP filter_sp;
   if (containingModules == nullptr) {
-    // We could make a special "CU List only SearchFilter".  Better yet was if
-    // these could be composable,
-    // but that will take a little reworking.
+    // We could make a special "CU List only SearchFilter".  Better yet
+    // was if these could be composable, but that will take a little
+    // reworking.
 
     filter_sp.reset(new SearchFilterByModuleListAndCU(
         shared_from_this(), FileSpecList(), *containingSourceFiles));
@@ -744,8 +746,8 @@
   return true;
 }
 
-// See also Watchpoint::SetWatchpointType(uint32_t type) and
-// the OptionGroupWatchpoint::WatchType enum type.
+// See also Watchpoint::SetWatchpointType(uint32_t type) and the
+// OptionGroupWatchpoint::WatchType enum type.
 WatchpointSP Target::CreateWatchpoint(lldb::addr_t addr, size_t size,
                                       const CompilerType *type, uint32_t kind,
                                       Status &error) {
@@ -776,8 +778,9 @@
   if (!CheckIfWatchpointsExhausted(this, error))
     return wp_sp;
 
-  // Currently we only support one watchpoint per address, with total number
-  // of watchpoints limited by the hardware which the inferior is running on.
+  // Currently we only support one watchpoint per address, with total
+  // number of watchpoints limited by the hardware which the inferior is
+  // running on.
 
   // Grab the list mutex while doing operations.
   const bool notify = false; // Don't notify about all the state changes we do
@@ -814,9 +817,8 @@
                 wp_sp->GetID());
 
   if (error.Fail()) {
-    // Enabling the watchpoint on the device side failed.
-    // Remove the said watchpoint from the list maintained by the target
-    // instance.
+    // Enabling the watchpoint on the device side failed. Remove the said
+    // watchpoint from the list maintained by the target instance.
     m_watchpoint_list.Remove(wp_sp->GetID(), true);
     // See if we could provide more helpful error message.
     if (!OptionGroupWatchpoint::IsWatchSizeSupported(size))
@@ -1028,8 +1030,7 @@
         Breakpoint *bp = GetBreakpointByID(bp_id).get();
         StructuredData::ObjectSP bkpt_save_sp = bp->SerializeToStructuredData();
         // If the user explicitly asked to serialize a breakpoint, and we
-        // can't, then
-        // raise an error:
+        // can't, then raise an error:
         if (!bkpt_save_sp) {
           error.SetErrorStringWithFormat("Unable to serialize breakpoint %d",
                                          bp_id);
@@ -1110,8 +1111,8 @@
 // The flag 'end_to_end', default to true, signifies that the operation is
 // performed end to end, for both the debugger and the debuggee.
 
-// Assumption: Caller holds the list mutex lock for m_watchpoint_list for end
-// to end operations.
+// Assumption: Caller holds the list mutex lock for m_watchpoint_list for
+// end to end operations.
 bool Target::RemoveAllWatchpoints(bool end_to_end) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
   if (log)
@@ -1142,8 +1143,8 @@
   return true; // Success!
 }
 
-// Assumption: Caller holds the list mutex lock for m_watchpoint_list for end to
-// end operations.
+// Assumption: Caller holds the list mutex lock for m_watchpoint_list for
+// end to end operations.
 bool Target::DisableAllWatchpoints(bool end_to_end) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
   if (log)
@@ -1172,8 +1173,8 @@
   return true; // Success!
 }
 
-// Assumption: Caller holds the list mutex lock for m_watchpoint_list for end to
-// end operations.
+// Assumption: Caller holds the list mutex lock for m_watchpoint_list for
+// end to end operations.
 bool Target::EnableAllWatchpoints(bool end_to_end) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
   if (log)
@@ -1378,7 +1379,8 @@
 }
 
 void Target::DidExec() {
-  // When a process exec's we need to know about it so we can do some cleanup.
+  // When a process exec's we need to know about it so we can do some
+  // cleanup.
   m_breakpoint_list.RemoveInvalidLocations(m_arch.GetSpec());
   m_internal_breakpoint_list.RemoveInvalidLocations(m_arch.GetSpec());
 }
@@ -1396,8 +1398,8 @@
 
     m_images.Append(executable_sp); // The first image is our executable file
 
-    // If we haven't set an architecture yet, reset our architecture based on
-    // what we found in the executable module.
+    // If we haven't set an architecture yet, reset our architecture based
+    // on what we found in the executable module.
     if (!m_arch.GetSpec().IsValid()) {
       m_arch = executable_sp->GetArchitecture();
       LLDB_LOG(log,
@@ -1459,8 +1461,9 @@
   }
 
   if (compatible_local_arch || missing_local_arch) {
-    // If we haven't got a valid arch spec, or the architectures are compatible
-    // update the architecture, unless the one we already have is more specified
+    // If we haven't got a valid arch spec, or the architectures are
+    // compatible update the architecture, unless the one we already have
+    // is more specified
     if (replace_local_arch)
       m_arch = other;
     LLDB_LOG(log, "set architecture to {0} ({1})",
@@ -1469,8 +1472,8 @@
     return true;
   }
 
-  // If we have an executable file, try to reset the executable to the desired
-  // architecture
+  // If we have an executable file, try to reset the executable to the
+  // desired architecture
   if (log)
     log->Printf("Target::SetArchitecture changing architecture to %s (%s)",
                 arch_spec.GetArchitectureName(),
@@ -1506,7 +1509,8 @@
       // The current target arch is compatible with "arch_spec", see if we
       // can improve our current architecture using bits from "arch_spec"
 
-      // Merge bits from arch_spec into "merged_arch" and set our architecture
+      // Merge bits from arch_spec into "merged_arch" and set our
+      // architecture
       ArchSpec merged_arch(m_arch.GetSpec());
       merged_arch.MergeFrom(arch_spec);
       return SetArchitecture(merged_arch);
@@ -1601,9 +1605,8 @@
     ModuleSpec module_spec(module_file_spec);
     size_t num_modules = GetImages().FindModules(module_spec, matchingModules);
 
-    // If there is more than one module for this file spec, only return true if
-    // ALL the modules are on the
-    // black list.
+    // If there is more than one module for this file spec, only return
+    // true if ALL the modules are on the black list.
     if (num_modules > 0) {
       for (size_t i = 0; i < num_modules; i++) {
         if (!ModuleIsExcludedForUnconstrainedSearches(
@@ -1663,8 +1666,8 @@
                           lldb::addr_t *load_addr_ptr) {
   error.Clear();
 
-  // if we end up reading this from process memory, we will fill this
-  // with the actual load address
+  // if we end up reading this from process memory, we will fill this with
+  // the actual load address
   if (load_addr_ptr)
     *load_addr_ptr = LLDB_INVALID_ADDRESS;
 
@@ -1676,15 +1679,15 @@
   if (!addr.IsSectionOffset()) {
     SectionLoadList &section_load_list = GetSectionLoadList();
     if (section_load_list.IsEmpty()) {
-      // No sections are loaded, so we must assume we are not running
-      // yet and anything we are given is a file address.
+      // No sections are loaded, so we must assume we are not running yet
+      // and anything we are given is a file address.
       file_addr = addr.GetOffset(); // "addr" doesn't have a section, so its
                                     // offset is the file address
       m_images.ResolveFileAddress(file_addr, resolved_addr);
     } else {
-      // We have at least one section loaded. This can be because
-      // we have manually loaded some sections with "target modules load ..."
-      // or because we have have a live process that has sections loaded
+      // We have at least one section loaded. This can be because we have
+      // manually loaded some sections with "target modules load ..." or
+      // because we have have a live process that has sections loaded
       // through the dynamic loader
       load_addr = addr.GetOffset(); // "addr" doesn't have a section, so its
                                     // offset is the load address
@@ -1735,8 +1738,8 @@
       // If the address is not section offset we have an address that
       // doesn't resolve to any address in any currently loaded shared
       // libraries and we failed to read memory so there isn't anything
-      // more we can do. If it is section offset, we might be able to
-      // read cached memory from the object file.
+      // more we can do. If it is section offset, we might be able to read
+      // cached memory from the object file.
       if (!resolved_addr.IsSectionOffset())
         return 0;
     }
@@ -1880,14 +1883,14 @@
         // yet and anything we are given is a file address.
         m_images.ResolveFileAddress(pointer_vm_addr, pointer_addr);
       } else {
-        // We have at least one section loaded. This can be because
-        // we have manually loaded some sections with "target modules load ..."
-        // or because we have have a live process that has sections loaded
-        // through the dynamic loader
+        // We have at least one section loaded. This can be because we
+        // have manually loaded some sections with "target modules load
+        // ..." or because we have have a live process that has sections
+        // loaded through the dynamic loader
         section_load_list.ResolveLoadAddress(pointer_vm_addr, pointer_addr);
       }
-      // We weren't able to resolve the pointer value, so just return
-      // an address with no section
+      // We weren't able to resolve the pointer value, so just return an
+      // address with no section
       if (!pointer_addr.IsValid())
         pointer_addr.SetOffset(pointer_vm_addr);
       return true;
@@ -1902,10 +1905,9 @@
 
   Status error;
 
-  // First see if we already have this module in our module list.  If we do,
-  // then we're done, we don't need
-  // to consult the shared modules list.  But only do this if we are passed a
-  // UUID.
+  // First see if we already have this module in our module list.  If we
+  // do, then we're done, we don't need to consult the shared modules
+  // list.  But only do this if we are passed a UUID.
 
   if (module_spec.GetUUID().IsValid())
     module_sp = m_images.FindFirstModule(module_spec);
@@ -1915,8 +1917,8 @@
                             // of the library
     bool did_create_module = false;
 
-    // If there are image search path entries, try to use them first to acquire
-    // a suitable image.
+    // If there are image search path entries, try to use them first to
+    // acquire a suitable image.
     if (m_image_search_paths.GetSize()) {
       ModuleSpec transformed_spec(module_spec);
       if (m_image_search_paths.RemapPath(
@@ -1931,14 +1933,14 @@
     }
 
     if (!module_sp) {
-      // If we have a UUID, we can check our global shared module list in case
-      // we already have it. If we don't have a valid UUID, then we can't since
-      // the path in "module_spec" will be a platform path, and we will need to
-      // let the platform find that file. For example, we could be asking for
-      // "/usr/lib/dyld" and if we do not have a UUID, we don't want to pick
-      // the local copy of "/usr/lib/dyld" since our platform could be a remote
-      // platform that has its own "/usr/lib/dyld" in an SDK or in a local file
-      // cache.
+      // If we have a UUID, we can check our global shared module list in
+      // case we already have it. If we don't have a valid UUID, then we
+      // can't since the path in "module_spec" will be a platform path,
+      // and we will need to let the platform find that file. For example,
+      // we could be asking for "/usr/lib/dyld" and if we do not have a
+      // UUID, we don't want to pick the local copy of "/usr/lib/dyld"
+      // since our platform could be a remote platform that has its own
+      // "/usr/lib/dyld" in an SDK or in a local file cache.
       if (module_spec.GetUUID().IsValid()) {
         // We have a UUID, it is OK to check the global module list...
         error = ModuleList::GetSharedModule(module_spec, module_sp,
@@ -1947,8 +1949,8 @@
       }
 
       if (!module_sp) {
-        // The platform is responsible for finding and caching an appropriate
-        // module in the shared module cache.
+        // The platform is responsible for finding and caching an
+        // appropriate module in the shared module cache.
         if (m_platform_sp) {
           error = m_platform_sp->GetSharedModule(
               module_spec, m_process_sp.get(), module_sp,
@@ -1959,9 +1961,9 @@
       }
     }
 
-    // We found a module that wasn't in our target list.  Let's make sure that
-    // there wasn't an equivalent
-    // module in the list already, and if there was, let's remove it.
+    // We found a module that wasn't in our target list.  Let's make sure
+    // that there wasn't an equivalent module in the list already, and if
+    // there was, let's remove it.
     if (module_sp) {
       ObjectFile *objfile = module_sp->GetObjectFile();
       if (objfile) {
@@ -1994,19 +1996,16 @@
                 "unsupported file type, please specify an executable");
           return ModuleSP();
         }
-        // GetSharedModule is not guaranteed to find the old shared module, for
-        // instance
-        // in the common case where you pass in the UUID, it is only going to
-        // find the one
-        // module matching the UUID.  In fact, it has no good way to know what
-        // the "old module"
-        // relevant to this target is, since there might be many copies of a
-        // module with this file spec
-        // in various running debug sessions, but only one of them will belong
-        // to this target.
-        // So let's remove the UUID from the module list, and look in the
-        // target's module list.
-        // Only do this if there is SOMETHING else in the module spec...
+        // GetSharedModule is not guaranteed to find the old shared
+        // module, for instance in the common case where you pass in the
+        // UUID, it is only going to find the one module matching the
+        // UUID.  In fact, it has no good way to know what the "old
+        // module" relevant to this target is, since there might be many
+        // copies of a module with this file spec in various running debug
+        // sessions, but only one of them will belong to this target. So
+        // let's remove the UUID from the module list, and look in the
+        // target's module list. Only do this if there is SOMETHING else
+        // in the module spec...
         if (!old_module_sp) {
           if (module_spec.GetUUID().IsValid() &&
               !module_spec.GetFileSpec().GetFilename().IsEmpty() &&
@@ -2023,8 +2022,8 @@
           }
         }
 
-        // Preload symbols outside of any lock, so hopefully we can do this for
-        // each library in parallel.
+        // Preload symbols outside of any lock, so hopefully we can do
+        // this for each library in parallel.
         if (GetPreloadSymbols())
           module_sp->PreloadSymbols();
 
@@ -2263,9 +2262,9 @@
 
 Target *Target::GetTargetFromContexts(const ExecutionContext *exe_ctx_ptr,
                                       const SymbolContext *sc_ptr) {
-  // The target can either exist in the "process" of ExecutionContext, or in
-  // the "target_sp" member of SymbolContext. This accessor helper function
-  // will get the target from one of these locations.
+  // The target can either exist in the "process" of ExecutionContext, or
+  // in the "target_sp" member of SymbolContext. This accessor helper
+  // function will get the target from one of these locations.
 
   Target *target = nullptr;
   if (sc_ptr != nullptr)
@@ -2286,8 +2285,8 @@
   if (expr.empty())
     return execution_results;
 
-  // We shouldn't run stop hooks in expressions.
-  // Be sure to reset this if you return anywhere within this function.
+  // We shouldn't run stop hooks in expressions. Be sure to reset this if
+  // you return anywhere within this function.
   bool old_suppress_value = m_suppress_stop_hooks;
   m_suppress_stop_hooks = true;
 
@@ -2400,12 +2399,12 @@
       if ((code_addr & 1ull) == 0) {
         // Bit zero isn't set, check if the address is a multiple of 2?
         if (code_addr & 2ull) {
-          // The address is a multiple of 2 so it must be thumb, set bit zero
+          // The address is a multiple of 2 so it must be thumb, set bit
+          // zero
           code_addr |= 1ull;
         } else if (addr_class == eAddressClassCodeAlternateISA) {
-          // We checked the address and the address claims to be the alternate
-          // ISA
-          // which means thumb, so set bit zero.
+          // We checked the address and the address claims to be the
+          // alternate ISA which means thumb, so set bit zero.
           code_addr |= 1ull;
         }
       }
@@ -2477,8 +2476,8 @@
     else
       section_load_list.ResolveLoadAddress(addr, resolved_addr);
 
-    // Get the function boundaries to make sure we don't scan back before the
-    // beginning of the current function.
+    // Get the function boundaries to make sure we don't scan back before
+    // the beginning of the current function.
     ModuleSP temp_addr_module_sp(resolved_addr.GetModule());
     if (temp_addr_module_sp) {
       SymbolContext sc;
@@ -2510,8 +2509,8 @@
       // Scan previous 6 bytes
       if (IsMips16 | IsMicromips)
         loop_count = 3;
-      // For mips-only, instructions are always 4 bytes, so scan previous 4
-      // bytes only.
+      // For mips-only, instructions are always 4 bytes, so scan previous
+      // 4 bytes only.
       else
         loop_count = 2;
     }
@@ -2540,37 +2539,38 @@
         prev_insn = disasm_sp->GetInstructionList().GetInstructionAtIndex(0);
         insn_size = prev_insn->GetOpcode().GetByteSize();
         if (i == 1 && insn_size == 2) {
-          // This looks like a valid 2-byte instruction (but it could be a part
-          // of upper 4 byte instruction).
+          // This looks like a valid 2-byte instruction (but it could be a
+          // part of upper 4 byte instruction).
           instruction_list.Append(prev_insn);
           inst_to_choose = 1;
         } else if (i == 2) {
-          // Here we may get one 4-byte instruction or two 2-byte instructions.
+          // Here we may get one 4-byte instruction or two 2-byte
+          // instructions.
           if (num_insns == 2) {
-            // Looks like there are two 2-byte instructions above our breakpoint
-            // target address.
-            // Now the upper 2-byte instruction is either a valid 2-byte
-            // instruction or could be a part of it's upper 4-byte instruction.
-            // In both cases we don't care because in this case lower 2-byte
-            // instruction is definitely a valid instruction
-            // and whatever i=1 iteration has found out is true.
+            // Looks like there are two 2-byte instructions above our
+            // breakpoint target address. Now the upper 2-byte instruction
+            // is either a valid 2-byte instruction or could be a part of
+            // it's upper 4-byte instruction. In both cases we don't care
+            // because in this case lower 2-byte instruction is definitely
+            // a valid instruction and whatever i=1 iteration has found
+            // out is true.
             inst_to_choose = 1;
             break;
           } else if (insn_size == 4) {
-            // This instruction claims its a valid 4-byte instruction. But it
-            // could be a part of it's upper 4-byte instruction.
-            // Lets try scanning upper 2 bytes to verify this.
+            // This instruction claims its a valid 4-byte instruction. But
+            // it could be a part of it's upper 4-byte instruction. Lets
+            // try scanning upper 2 bytes to verify this.
             instruction_list.Append(prev_insn);
             inst_to_choose = 2;
           }
         } else if (i == 3) {
           if (insn_size == 4)
-            // FIXME: We reached here that means instruction at [target - 4] has
-            // already claimed to be a 4-byte instruction,
-            // and now instruction at [target - 6] is also claiming that it's a
-            // 4-byte instruction. This can not be true.
-            // In this case we can not decide the valid previous instruction so
-            // we let lldb set the breakpoint at the address given by user.
+            // FIXME: We reached here that means instruction at [target -
+            // 4] has already claimed to be a 4-byte instruction, and now
+            // instruction at [target - 6] is also claiming that it's a
+            // 4-byte instruction. This can not be true. In this case we
+            // can not decide the valid previous instruction so we let
+            // lldb set the breakpoint at the address given by user.
             inst_to_choose = 0;
           else
             // This is straight-forward
@@ -2578,8 +2578,8 @@
           break;
         }
       } else {
-        // Decode failed, bytes do not form a valid instruction. So whatever
-        // previous iteration has found out is true.
+        // Decode failed, bytes do not form a valid instruction. So
+        // whatever previous iteration has found out is true.
         if (i > 1) {
           inst_to_choose = i - 1;
           break;
@@ -2686,8 +2686,8 @@
     return;
 
   // <rdar://problem/12027563> make sure we check that we are not stopped
-  // because of us running a user expression
-  // since in that case we do not want to run the stop-hooks
+  // because of us running a user expression since in that case we do not
+  // want to run the stop-hooks
   if (m_process_sp->GetModIDRef().IsLastResumeForUserExpression())
     return;
 
@@ -2785,8 +2785,8 @@
             cur_hook_sp->GetCommands(), &exc_ctx_with_reasons[i], options,
             result);
 
-        // If the command started the target going again, we should bag out of
-        // running the stop hooks.
+        // If the command started the target going again, we should bag
+        // out of running the stop hooks.
         if ((result.GetStatus() == eReturnStatusSuccessContinuingNoResult) ||
             (result.GetStatus() == eReturnStatusSuccessContinuingResult)) {
           // But only complain if there were more stop hooks to do:
@@ -2806,8 +2806,8 @@
 }
 
 const TargetPropertiesSP &Target::GetGlobalProperties() {
-  // NOTE: intentional leak so we don't crash if global destructor chain gets
-  // called as other threads still use the result of this function
+  // NOTE: intentional leak so we don't crash if global destructor chain
+  // gets called as other threads still use the result of this function
   static TargetPropertiesSP *g_settings_sp_ptr =
       new TargetPropertiesSP(new TargetProperties(nullptr));
   return *g_settings_sp_ptr;
@@ -2819,8 +2819,8 @@
   if (platform_sp) {
     if (platform_sp->IsRemote()) {
       if (platform_sp->IsConnected()) {
-        // Install all files that have an install path, and always install the
-        // main executable when connected to a remote platform
+        // Install all files that have an install path, and always install
+        // the main executable when connected to a remote platform
         const ModuleList &modules = GetImages();
         const size_t num_images = modules.GetSize();
         for (size_t idx = 0; idx < num_images; ++idx) {
@@ -2954,9 +2954,9 @@
 
   StateType state = eStateInvalid;
 
-  // Scope to temporarily get the process state in case someone has manually
-  // remotely connected already to a process and we can skip the platform
-  // launching.
+  // Scope to temporarily get the process state in case someone has
+  // manually remotely connected already to a process and we can skip the
+  // platform launching.
   {
     ProcessSP process_sp(GetProcessSP());
 
@@ -2975,11 +2975,10 @@
 
   launch_info.GetFlags().Set(eLaunchFlagDebug);
 
-  // Get the value of synchronous execution here.  If you wait till after you
-  // have started to
-  // run, then you could have hit a breakpoint, whose command might switch the
-  // value, and
-  // then you'll pick up that incorrect value.
+  // Get the value of synchronous execution here.  If you wait till after
+  // you have started to run, then you could have hit a breakpoint, whose
+  // command might switch the value, and then you'll pick up that
+  // incorrect value.
   Debugger &debugger = GetDebugger();
   const bool synchronous_execution =
       debugger.GetCommandInterpreter().GetSynchronous();
@@ -3010,8 +3009,9 @@
   if (!launch_info.GetArchitecture().IsValid())
     launch_info.GetArchitecture() = GetArchitecture();
 
-  // If we're not already connected to the process, and if we have a platform
-  // that can launch a process for debugging, go ahead and do that here.
+  // If we're not already connected to the process, and if we have a
+  // platform that can launch a process for debugging, go ahead and do
+  // that here.
   if (state != eStateConnected && platform_sp &&
       platform_sp->CanDebugProcess()) {
     if (log)
@@ -3153,8 +3153,8 @@
 
   const ModuleSP old_exec_module_sp = GetExecutableModule();
 
-  // If no process info was specified, then use the target executable
-  // name as the process to attach to by default
+  // If no process info was specified, then use the target executable name
+  // as the process to attach to by default
   if (!attach_info.ProcessInfoSpecified()) {
     if (old_exec_module_sp)
       attach_info.GetExecutableFile().GetFilename() =
@@ -3466,8 +3466,9 @@
      "This setting allows you to control exactly which strategy is used when "
      "setting "
      "file and line breakpoints."},
-    // FIXME: This is the wrong way to do per-architecture settings, but we
-    // don't have a general per architecture settings system in place yet.
+    // FIXME: This is the wrong way to do per-architecture settings, but
+    // we don't have a general per architecture settings system in place
+    // yet.
     {"x86-disassembly-flavor", OptionValue::eTypeEnum, false,
      eX86DisFlavorDefault, nullptr, g_x86_dis_flavor_value_types,
      "The default disassembly flavor to use for x86 or x86-64 targets."},
@@ -3569,9 +3570,9 @@
   TargetOptionValueProperties(const ConstString &name)
       : OptionValueProperties(name), m_target(nullptr), m_got_host_env(false) {}
 
-  // This constructor is used when creating TargetOptionValueProperties when it
-  // is part of a new lldb_private::Target instance. It will copy all current
-  // global property values as needed
+  // This constructor is used when creating TargetOptionValueProperties
+  // when it is part of a new lldb_private::Target instance. It will copy
+  // all current global property values as needed
   TargetOptionValueProperties(Target *target,
                               const TargetPropertiesSP &target_properties_sp)
       : OptionValueProperties(*target_properties_sp->GetValueProperties()),
@@ -3580,10 +3581,9 @@
   const Property *GetPropertyAtIndex(const ExecutionContext *exe_ctx,
                                      bool will_modify,
                                      uint32_t idx) const override {
-    // When getting the value for a key from the target options, we will always
-    // try and grab the setting from the current target if there is one. Else we
-    // just
-    // use the one from this instance.
+    // When getting the value for a key from the target options, we will
+    // always try and grab the setting from the current target if there is
+    // one. Else we just use the one from this instance.
     if (idx == ePropertyEnvVars)
       GetHostEnvironmentIfNeeded();
 
@@ -3619,8 +3619,8 @@
             if (env_dict) {
               const bool can_replace = false;
               for (const auto &KV : env) {
-                // Don't allow existing keys to be replaced with ones we get
-                // from the platform environment
+                // Don't allow existing keys to be replaced with ones we
+                // get from the platform environment
                 env_dict->SetValueForKey(
                     ConstString(KV.first()),
                     OptionValueSP(new OptionValueString(KV.second.c_str())),
@@ -3674,8 +3674,8 @@
     m_collection_sp.reset(
         new TargetOptionValueProperties(target, Target::GetGlobalProperties()));
 
-    // Set callbacks to update launch_info whenever "settins set" updated any of
-    // these properties
+    // Set callbacks to update launch_info whenever "settins set" updated
+    // any of these properties
     m_collection_sp->SetValueChangedCallback(
         ePropertyArg0, TargetProperties::Arg0ValueChangedCallback, this);
     m_collection_sp->SetValueChangedCallback(
@@ -3711,8 +3711,8 @@
     // Update m_launch_info once it was created
     Arg0ValueChangedCallback(this, nullptr);
     RunArgsValueChangedCallback(this, nullptr);
-    // EnvVarsValueChangedCallback(this, nullptr); // FIXME: cause segfault in
-    // Target::GetPlatform()
+    // EnvVarsValueChangedCallback(this, nullptr); // FIXME: cause
+    // segfault in Target::GetPlatform()
     InputPathValueChangedCallback(this, nullptr);
     OutputPathValueChangedCallback(this, nullptr);
     ErrorPathValueChangedCallback(this, nullptr);
Index: source/Target/TargetList.cpp
===================================================================
--- source/Target/TargetList.cpp
+++ source/Target/TargetList.cpp
@@ -85,8 +85,8 @@
   PlatformSP platform_sp;
 
   // This is purposely left empty unless it is specified by triple_cstr.
-  // If not initialized via triple_cstr, then the currently selected platform
-  // will set the architecture correctly.
+  // If not initialized via triple_cstr, then the currently selected
+  // platform will set the architecture correctly.
   const ArchSpec arch(triple_str);
   if (!triple_str.empty()) {
     if (!arch.IsValid()) {
@@ -102,8 +102,8 @@
 
   CommandInterpreter &interpreter = debugger.GetCommandInterpreter();
 
-  // let's see if there is already an existing plaform before we go creating
-  // another...
+  // let's see if there is already an existing plaform before we go
+  // creating another...
   platform_sp = debugger.GetPlatformList().GetSelectedPlatform();
 
   if (platform_options && platform_options->PlatformWasSpecified()) {
@@ -123,8 +123,7 @@
     module_spec.GetFileSpec().SetFile(user_exe_path, true);
 
     // Resolve the executable in case we are given a path to a application
-    // bundle
-    // like a .app bundle on MacOSX
+    // bundle like a .app bundle on MacOSX
     Host::ResolveExecutableInBundle(module_spec.GetFileSpec());
 
     lldb::offset_t file_offset = 0;
@@ -139,8 +138,9 @@
           if (platform_arch.IsValid()) {
             if (platform_arch.IsCompatibleMatch(
                     matching_module_spec.GetArchitecture())) {
-              // If the OS or vendor weren't specified, then adopt the module's
-              // architecture so that the platform matching can be more accurate
+              // If the OS or vendor weren't specified, then adopt the
+              // module's architecture so that the platform matching can
+              // be more accurate
               if (!platform_arch.TripleOSWasSpecified() ||
                   !platform_arch.TripleVendorWasSpecified()) {
                 prefer_platform_arch = true;
@@ -175,8 +175,8 @@
             platform_arch = matching_module_spec.GetArchitecture();
           }
         } else {
-          // No architecture specified, check if there is only one platform for
-          // all of the architectures.
+          // No architecture specified, check if there is only one
+          // platform for all of the architectures.
 
           typedef std::vector<PlatformSP> PlatformList;
           PlatformList platforms;
@@ -194,7 +194,8 @@
                 }
               }
 
-              // Next check the host platform it if wasn't already checked above
+              // Next check the host platform it if wasn't already checked
+              // above
               if (host_platform_sp &&
                   (!platform_sp ||
                    host_platform_sp->GetName() != platform_sp->GetName())) {
@@ -231,8 +232,8 @@
           }
 
           if (platform_ptr) {
-            // All platforms for all modules in the exectuable match, so we can
-            // select this platform
+            // All platforms for all modules in the exectuable match, so
+            // we can select this platform
             platform_sp = platforms.front();
           } else if (more_than_one_platforms == false) {
             // No platforms claim to support this file
@@ -275,8 +276,7 @@
     }
   } else if (platform_arch.IsValid()) {
     // if "arch" isn't valid, yet "platform_arch" is, it means we have an
-    // executable file with
-    // a single architecture which should be used
+    // executable file with a single architecture which should be used
     ArchSpec fixed_platform_arch;
     if (!platform_sp->IsCompatibleArchitecture(platform_arch, false,
                                                &fixed_platform_arch)) {
@@ -347,8 +347,9 @@
 
   FileSpec file(user_exe_path, false);
   if (!file.Exists() && user_exe_path.startswith("~")) {
-    // we want to expand the tilde but we don't want to resolve any symbolic
-    // links so we can't use the FileSpec constructor's resolve flag
+    // we want to expand the tilde but we don't want to resolve any
+    // symbolic links so we can't use the FileSpec constructor's resolve
+    // flag
     llvm::SmallString<64> unglobbed_path;
     StandardTildeExpressionResolver Resolver;
     Resolver.ResolveFullPath(user_exe_path, unglobbed_path);
@@ -410,18 +411,19 @@
                                              sizeof(resolved_bundle_exe_path));
     }
   } else {
-    // No file was specified, just create an empty target with any arch
-    // if a valid arch was specified
+    // No file was specified, just create an empty target with any arch if
+    // a valid arch was specified
     target_sp.reset(new Target(debugger, arch, platform_sp, is_dummy_target));
   }
 
   if (target_sp) {
     // Set argv0 with what the user typed, unless the user specified a
     // directory. If the user specified a directory, then it is probably a
-    // bundle that was resolved and we need to use the resolved bundle path
+    // bundle that was resolved and we need to use the resolved bundle
+    // path
     if (!user_exe_path.empty()) {
-      // Use exactly what the user typed as the first argument when we exec or
-      // posix_spawn
+      // Use exactly what the user typed as the first argument when we
+      // exec or posix_spawn
       if (user_exe_path_is_bundle && resolved_bundle_exe_path[0]) {
         target_sp->SetArg0(resolved_bundle_exe_path);
       } else {
@@ -435,7 +437,8 @@
       target_sp->GetExecutableSearchPaths().Append(file_dir);
     }
 
-    // Don't put the dummy target in the target list, it's held separately.
+    // Don't put the dummy target in the target list, it's held
+    // separately.
     if (!is_dummy_target) {
       std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
       m_selected_target_idx = m_target_list.size();
@@ -545,8 +548,8 @@
       }
     }
   } else {
-    // We don't have a valid pid to broadcast to, so broadcast to the target
-    // list's async broadcaster...
+    // We don't have a valid pid to broadcast to, so broadcast to the
+    // target list's async broadcaster...
     BroadcastEvent(Process::eBroadcastBitInterrupt, nullptr);
   }
 
Index: source/Target/Thread.cpp
===================================================================
--- source/Target/Thread.cpp
+++ source/Target/Thread.cpp
@@ -57,8 +57,8 @@
 using namespace lldb_private;
 
 const ThreadPropertiesSP &Thread::GetGlobalProperties() {
-  // NOTE: intentional leak so we don't crash if global destructor chain gets
-  // called as other threads still use the result of this function
+  // NOTE: intentional leak so we don't crash if global destructor chain
+  // gets called as other threads still use the result of this function
   static ThreadPropertiesSP *g_settings_sp_ptr =
       new ThreadPropertiesSP(new ThreadProperties(true));
   return *g_settings_sp_ptr;
@@ -95,19 +95,18 @@
   ThreadOptionValueProperties(const ConstString &name)
       : OptionValueProperties(name) {}
 
-  // This constructor is used when creating ThreadOptionValueProperties when it
-  // is part of a new lldb_private::Thread instance. It will copy all current
-  // global property values as needed
+  // This constructor is used when creating ThreadOptionValueProperties
+  // when it is part of a new lldb_private::Thread instance. It will copy
+  // all current global property values as needed
   ThreadOptionValueProperties(ThreadProperties *global_properties)
       : OptionValueProperties(*global_properties->GetValueProperties()) {}
 
   const Property *GetPropertyAtIndex(const ExecutionContext *exe_ctx,
                                      bool will_modify,
                                      uint32_t idx) const override {
-    // When getting the value for a key from the thread options, we will always
-    // try and grab the setting from the current thread if there is one. Else we
-    // just
-    // use the one from this instance.
+    // When getting the value for a key from the thread options, we will
+    // always try and grab the setting from the current thread if there is
+    // one. Else we just use the one from this instance.
     if (exe_ctx) {
       Thread *thread = exe_ctx->GetThreadPtr();
       if (thread) {
@@ -274,9 +273,9 @@
 }
 
 void Thread::DestroyThread() {
-  // Tell any plans on the plan stacks that the thread is being destroyed since
-  // any plans that have a thread go away in the middle of might need
-  // to do cleanup, or in some cases NOT do cleanup...
+  // Tell any plans on the plan stacks that the thread is being destroyed
+  // since any plans that have a thread go away in the middle of might
+  // need to do cleanup, or in some cases NOT do cleanup...
   for (auto plan : m_plan_stack)
     plan->ThreadDestroyed();
 
@@ -291,11 +290,10 @@
   m_discarded_plan_stack.clear();
   m_completed_plan_stack.clear();
 
-  // Push a ThreadPlanNull on the plan stack.  That way we can continue assuming
-  // that the
-  // plan stack is never empty, but if somebody errantly asks questions of a
-  // destroyed thread
-  // without checking first whether it is destroyed, they won't crash.
+  // Push a ThreadPlanNull on the plan stack.  That way we can continue
+  // assuming that the plan stack is never empty, but if somebody errantly
+  // asks questions of a destroyed thread without checking first whether
+  // it is destroyed, they won't crash.
   ThreadPlanSP null_plan_sp(new ThreadPlanNull(*this));
   m_plan_stack.push_back(null_plan_sp);
 
@@ -385,11 +383,10 @@
   ProcessSP process_sp(GetProcess());
   const uint32_t stop_id = process_sp ? process_sp->GetStopID() : UINT32_MAX;
 
-  // Here we select the stop info according to priorirty:
-  // - m_stop_info_sp (if not trace) - preset value
-  // - completed plan stop info - new value with plan from completed plan stack
-  // - m_stop_info_sp (trace stop reason is OK now)
-  // - ask GetPrivateStopInfo to set stop info
+  // Here we select the stop info according to priorirty: - m_stop_info_sp
+  // (if not trace) - preset value - completed plan stop info - new value
+  // with plan from completed plan stack - m_stop_info_sp (trace stop
+  // reason is OK now) - ask GetPrivateStopInfo to set stop info
 
   bool have_valid_stop_info = m_stop_info_sp &&
       m_stop_info_sp ->IsValid() &&
@@ -434,11 +431,11 @@
 
     // The stop info can be manually set by calling Thread::SetStopInfo()
     // prior to this function ever getting called, so we can't rely on
-    // "m_stop_info_stop_id != process_stop_id" as the condition for
-    // the if statement below, we must also check the stop info to see
-    // if we need to override it. See the header documentation in
-    // Process::GetStopInfoOverrideCallback() for more information on
-    // the stop info override callback.
+    // "m_stop_info_stop_id != process_stop_id" as the condition for the
+    // if statement below, we must also check the stop info to see if we
+    // need to override it. See the header documentation in
+    // Process::GetStopInfoOverrideCallback() for more information on the
+    // stop info override callback.
     if (m_stop_info_override_stop_id != process_stop_id) {
       m_stop_info_override_stop_id = process_stop_id;
       if (m_stop_info_sp) {
@@ -509,9 +506,8 @@
 
 void Thread::SetStopInfoToNothing() {
   // Note, we can't just NULL out the private reason, or the native thread
-  // implementation will try to
-  // go calculate it again.  For now, just set it to a Unix Signal with an
-  // invalid signal number.
+  // implementation will try to go calculate it again.  For now, just set
+  // it to a Unix Signal with an invalid signal number.
   SetStopInfo(
       StopInfo::CreateStopReasonWithSignal(*this, LLDB_INVALID_SIGNAL_NUMBER));
 }
@@ -592,8 +588,8 @@
 void Thread::WillStop() {
   ThreadPlan *current_plan = GetCurrentPlan();
 
-  // FIXME: I may decide to disallow threads with no plans.  In which
-  // case this should go to an assert.
+  // FIXME: I may decide to disallow threads with no plans.  In which case
+  // this should go to an assert.
 
   if (!current_plan)
     return;
@@ -603,11 +599,9 @@
 
 void Thread::SetupForResume() {
   if (GetResumeState() != eStateSuspended) {
-    // If we're at a breakpoint push the step-over breakpoint plan.  Do this
-    // before
-    // telling the current plan it will resume, since we might change what the
-    // current
-    // plan is.
+    // If we're at a breakpoint push the step-over breakpoint plan.  Do
+    // this before telling the current plan it will resume, since we might
+    // change what the current plan is.
 
     lldb::RegisterContextSP reg_ctx_sp(GetRegisterContext());
     if (reg_ctx_sp) {
@@ -615,9 +609,9 @@
       BreakpointSiteSP bp_site_sp =
           GetProcess()->GetBreakpointSiteList().FindByAddress(thread_pc);
       if (bp_site_sp) {
-        // Note, don't assume there's a ThreadPlanStepOverBreakpoint, the target
-        // may not require anything
-        // special to step over a breakpoint.
+        // Note, don't assume there's a ThreadPlanStepOverBreakpoint, the
+        // target may not require anything special to step over a
+        // breakpoint.
 
         ThreadPlan *cur_plan = GetCurrentPlan();
 
@@ -663,18 +657,16 @@
   if (backing_thread_sp)
     backing_thread_sp->SetTemporaryResumeState(resume_state);
 
-  // Make sure m_stop_info_sp is valid.  Don't do this for threads we suspended
-  // in the previous run.
+  // Make sure m_stop_info_sp is valid.  Don't do this for threads we
+  // suspended in the previous run.
   if (prev_resume_state != eStateSuspended)
     GetPrivateStopInfo();
 
-  // This is a little dubious, but we are trying to limit how often we actually
-  // fetch stop info from
-  // the target, 'cause that slows down single stepping.  So assume that if we
-  // got to the point where
-  // we're about to resume, and we haven't yet had to fetch the stop reason,
-  // then it doesn't need to know
-  // about the fact that we are resuming...
+  // This is a little dubious, but we are trying to limit how often we
+  // actually fetch stop info from the target, 'cause that slows down
+  // single stepping.  So assume that if we got to the point where we're
+  // about to resume, and we haven't yet had to fetch the stop reason,
+  // then it doesn't need to know about the fact that we are resuming...
   const uint32_t process_stop_id = GetProcess()->GetStopID();
   if (m_stop_info_stop_id == process_stop_id &&
       (m_stop_info_sp && m_stop_info_sp->IsValid())) {
@@ -683,10 +675,10 @@
       stop_info->WillResume(resume_state);
   }
 
-  // Tell all the plans that we are about to resume in case they need to clear
-  // any state.
-  // We distinguish between the plan on the top of the stack and the lower
-  // plans in case a plan needs to do any special business before it runs.
+  // Tell all the plans that we are about to resume in case they need to
+  // clear any state. We distinguish between the plan on the top of the
+  // stack and the lower plans in case a plan needs to do any special
+  // business before it runs.
 
   bool need_to_resume = false;
   ThreadPlan *plan_ptr = GetCurrentPlan();
@@ -697,9 +689,9 @@
       plan_ptr->WillResume(resume_state, false);
     }
 
-    // If the WillResume for the plan says we are faking a resume, then it will
-    // have set an appropriate stop info.
-    // In that case, don't reset it here.
+    // If the WillResume for the plan says we are faking a resume, then it
+    // will have set an appropriate stop info. In that case, don't reset
+    // it here.
 
     if (need_to_resume && resume_state != eStateSuspended) {
       m_stop_info_sp.reset();
@@ -708,7 +700,8 @@
 
   if (need_to_resume) {
     ClearStackFrames();
-    // Let Thread subclasses do any special work they need to prior to resuming
+    // Let Thread subclasses do any special work they need to prior to
+    // resuming
     WillResume(resume_state);
   }
 
@@ -775,10 +768,9 @@
   current_plan->DoTraceLog();
 
   // First query the stop info's ShouldStopSynchronous.  This handles
-  // "synchronous" stop reasons, for example the breakpoint
-  // command on internal breakpoints.  If a synchronous stop reason says we
-  // should not stop, then we don't have to
-  // do any more work on this stop.
+  // "synchronous" stop reasons, for example the breakpoint command on
+  // internal breakpoints.  If a synchronous stop reason says we should
+  // not stop, then we don't have to do any more work on this stop.
   StopInfoSP private_stop_info(GetPrivateStopInfo());
   if (private_stop_info &&
       !private_stop_info->ShouldStopSynchronous(event_ptr)) {
@@ -788,22 +780,21 @@
     return false;
   }
 
-  // If we've already been restarted, don't query the plans since the state they
-  // would examine is not current.
+  // If we've already been restarted, don't query the plans since the
+  // state they would examine is not current.
   if (Process::ProcessEventData::GetRestartedFromEvent(event_ptr))
     return false;
 
-  // Before the plans see the state of the world, calculate the current inlined
-  // depth.
+  // Before the plans see the state of the world, calculate the current
+  // inlined depth.
   GetStackFrameList()->CalculateCurrentInlinedDepth();
 
-  // If the base plan doesn't understand why we stopped, then we have to find a
-  // plan that does.
-  // If that plan is still working, then we don't need to do any more work.  If
-  // the plan that explains
-  // the stop is done, then we should pop all the plans below it, and pop it,
-  // and then let the plans above it decide
-  // whether they still need to do more work.
+  // If the base plan doesn't understand why we stopped, then we have to
+  // find a plan that does. If that plan is still working, then we don't
+  // need to do any more work.  If the plan that explains the stop is
+  // done, then we should pop all the plans below it, and pop it, and then
+  // let the plans above it decide whether they still need to do more
+  // work.
 
   bool done_processing_current_plan = false;
 
@@ -819,13 +810,13 @@
         if (plan_ptr->PlanExplainsStop(event_ptr)) {
           should_stop = plan_ptr->ShouldStop(event_ptr);
 
-          // plan_ptr explains the stop, next check whether plan_ptr is done, if
-          // so, then we should take it
-          // and all the plans below it off the stack.
+          // plan_ptr explains the stop, next check whether plan_ptr is
+          // done, if so, then we should take it and all the plans below
+          // it off the stack.
 
           if (plan_ptr->MischiefManaged()) {
-            // We're going to pop the plans up to and including the plan that
-            // explains the stop.
+            // We're going to pop the plans up to and including the plan
+            // that explains the stop.
             ThreadPlan *prev_plan_ptr = GetPreviousPlan(plan_ptr);
 
             do {
@@ -833,9 +824,9 @@
                 current_plan->WillStop();
               PopPlan();
             } while ((current_plan = GetCurrentPlan()) != prev_plan_ptr);
-            // Now, if the responsible plan was not "Okay to discard" then we're
-            // done,
-            // otherwise we forward this to the next plan in the stack below.
+            // Now, if the responsible plan was not "Okay to discard" then
+            // we're done, otherwise we forward this to the next plan in
+            // the stack below.
             done_processing_current_plan =
                 (plan_ptr->IsMasterPlan() && !plan_ptr->OkayToDiscard());
           } else
@@ -860,9 +851,9 @@
       if (log)
         log->Printf("Base plan says should stop: %i.", should_stop);
     } else {
-      // Otherwise, don't let the base plan override what the other plans say to
-      // do, since
-      // presumably if there were other plans they would know what to do...
+      // Otherwise, don't let the base plan override what the other plans
+      // say to do, since presumably if there were other plans they would
+      // know what to do...
       while (1) {
         if (PlanIsBasePlan(current_plan))
           break;
@@ -875,9 +866,9 @@
           if (should_stop)
             current_plan->WillStop();
 
-          // If a Master Plan wants to stop, and wants to stick on the stack, we
-          // let it.
-          // Otherwise, see if the plan's parent wants to stop.
+          // If a Master Plan wants to stop, and wants to stick on the
+          // stack, we let it. Otherwise, see if the plan's parent wants
+          // to stop.
 
           if (should_stop && current_plan->IsMasterPlan() &&
               !current_plan->OkayToDiscard()) {
@@ -901,19 +892,18 @@
       should_stop = false;
   }
 
-  // One other potential problem is that we set up a master plan, then stop in
-  // before it is complete - for instance
-  // by hitting a breakpoint during a step-over - then do some step/finish/etc
-  // operations that wind up
-  // past the end point condition of the initial plan.  We don't want to strand
-  // the original plan on the stack,
-  // This code clears stale plans off the stack.
+  // One other potential problem is that we set up a master plan, then
+  // stop in before it is complete - for instance by hitting a breakpoint
+  // during a step-over - then do some step/finish/etc operations that
+  // wind up past the end point condition of the initial plan.  We don't
+  // want to strand the original plan on the stack, This code clears stale
+  // plans off the stack.
 
   if (should_stop) {
     ThreadPlan *plan_ptr = GetCurrentPlan();
 
-    // Discard the stale plans and all plans below them in the stack,
-    // plus move the completed plans to the completed plan stack
+    // Discard the stale plans and all plans below them in the stack, plus
+    // move the completed plans to the completed plan stack
     while (!PlanIsBasePlan(plan_ptr)) {
       bool stale = plan_ptr->IsPlanStale();
       ThreadPlan *examined_plan = plan_ptr;
@@ -928,8 +918,9 @@
           DiscardPlan();
         }
         if (examined_plan->IsPlanComplete()) {
-          // plan is complete but does not explain the stop (example: step to a line
-          // with breakpoint), let us move the plan to completed_plan_stack anyway
+          // plan is complete but does not explain the stop (example: step
+          // to a line with breakpoint), let us move the plan to
+          // completed_plan_stack anyway
           PopPlan();
         } else
           DiscardPlan();
@@ -981,7 +972,8 @@
   }
 
   if (m_completed_plan_stack.size() > 0) {
-    // Don't use GetCompletedPlan here, since that suppresses private plans.
+    // Don't use GetCompletedPlan here, since that suppresses private
+    // plans.
     if (log)
       log->Printf("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64
                   ": returning vote  for complete stack's back plan",
@@ -1018,7 +1010,8 @@
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
   if (m_completed_plan_stack.size() > 0) {
-    // Don't use GetCompletedPlan here, since that suppresses private plans.
+    // Don't use GetCompletedPlan here, since that suppresses private
+    // plans.
     if (log)
       log->Printf("Current Plan for thread %d(%p) (0x%4.4" PRIx64
                   ", %s): %s being asked whether we should report run.",
@@ -1045,8 +1038,8 @@
 
 void Thread::PushPlan(ThreadPlanSP &thread_plan_sp) {
   if (thread_plan_sp) {
-    // If the thread plan doesn't already have a tracer, give it its parent's
-    // tracer:
+    // If the thread plan doesn't already have a tracer, give it its
+    // parent's tracer:
     if (!thread_plan_sp->GetThreadPlanTracer())
       thread_plan_sp->SetThreadPlanTracer(
           m_plan_stack.back()->GetThreadPlanTracer());
@@ -1097,8 +1090,8 @@
 }
 
 ThreadPlan *Thread::GetCurrentPlan() {
-  // There will always be at least the base plan.  If somebody is mucking with a
-  // thread with an empty plan stack, we should assert right away.
+  // There will always be at least the base plan.  If somebody is mucking
+  // with a thread with an empty plan stack, we should assert right away.
   return m_plan_stack.empty() ? nullptr : m_plan_stack.back().get();
 }
 
@@ -1211,9 +1204,8 @@
 }
 
 bool Thread::DiscardUserThreadPlansUpToIndex(uint32_t thread_index) {
-  // Count the user thread plans from the back end to get the number of the one
-  // we want
-  // to discard:
+  // Count the user thread plans from the back end to get the number of
+  // the one we want to discard:
 
   uint32_t idx = 0;
   ThreadPlan *up_to_plan_ptr = nullptr;
@@ -1248,9 +1240,8 @@
 
   int stack_size = m_plan_stack.size();
 
-  // If the input plan is nullptr, discard all plans.  Otherwise make sure this
-  // plan is in the
-  // stack, and if so discard up to and including it.
+  // If the input plan is nullptr, discard all plans.  Otherwise make sure
+  // this plan is in the stack, and if so discard up to and including it.
 
   if (up_to_plan_ptr == nullptr) {
     for (int i = stack_size - 1; i > 0; i--)
@@ -1306,21 +1297,20 @@
       // First pop all the dependent plans:
       for (int i = m_plan_stack.size() - 1; i > master_plan_idx; i--) {
         // FIXME: Do we need a finalize here, or is the rule that
-        // "PrepareForStop"
-        // for the plan leaves it in a state that it is safe to pop the plan
-        // with no more notice?
+        // "PrepareForStop" for the plan leaves it in a state that it is
+        // safe to pop the plan with no more notice?
         DiscardPlan();
       }
 
       // Now discard the master plan itself.
-      // The bottom-most plan never gets discarded.  "OkayToDiscard" for it
-      // means
-      // discard it's dependent plans, but not it...
+      // The bottom-most plan never gets discarded.  "OkayToDiscard" for
+      // it means discard it's dependent plans, but not it...
       if (master_plan_idx > 0) {
         DiscardPlan();
       }
     } else {
-      // If the master plan doesn't want to get discarded, then we're done.
+      // If the master plan doesn't want to get discarded, then we're
+      // done.
       break;
     }
   }
@@ -1339,9 +1329,8 @@
   Status error;
   int stack_size = m_plan_stack.size();
 
-  // If the input plan is nullptr, discard all plans.  Otherwise make sure this
-  // plan is in the
-  // stack, and if so discard up to and including it.
+  // If the input plan is nullptr, discard all plans.  Otherwise make sure
+  // this plan is in the stack, and if so discard up to and including it.
 
   for (int i = stack_size - 1; i > 0; i--) {
     if (m_plan_stack[i]->GetKind() == ThreadPlan::eKindCallFunction) {
@@ -1380,7 +1369,8 @@
   return thread_plan_sp;
 }
 
-// Call the QueueThreadPlanForStepOverRange method which takes an address range.
+// Call the QueueThreadPlanForStepOverRange method which takes an address
+// range.
 ThreadPlanSP Thread::QueueThreadPlanForStepOverRange(
     bool abort_other_plans, const LineEntry &line_entry,
     const SymbolContext &addr_context, lldb::RunMode stop_other_threads,
@@ -1411,7 +1401,8 @@
   return thread_plan_sp;
 }
 
-// Call the QueueThreadPlanForStepInRange method which takes an address range.
+// Call the QueueThreadPlanForStepInRange method which takes an address
+// range.
 ThreadPlanSP Thread::QueueThreadPlanForStepInRange(
     bool abort_other_plans, const LineEntry &line_entry,
     const SymbolContext &addr_context, const char *step_in_target,
@@ -1500,11 +1491,9 @@
   ThreadPlanSP thread_plan_sp(new ThreadPlanPython(*this, class_name));
   QueueThreadPlan(thread_plan_sp, abort_other_plans);
   // This seems a little funny, but I don't want to have to split up the
-  // constructor and the
-  // DidPush in the scripted plan, that seems annoying.
-  // That means the constructor has to be in DidPush.
-  // So I have to validate the plan AFTER pushing it, and then take it off
-  // again...
+  // constructor and the DidPush in the scripted plan, that seems
+  // annoying. That means the constructor has to be in DidPush. So I have
+  // to validate the plan AFTER pushing it, and then take it off again...
   if (!thread_plan_sp->ValidatePlan(nullptr)) {
     DiscardThreadPlansUpToPlan(thread_plan_sp);
     return ThreadPlanSP();
@@ -1619,10 +1608,9 @@
     unwinder->Clear();
 
   // Only store away the old "reference" StackFrameList if we got all its
-  // frames:
-  // FIXME: At some point we can try to splice in the frames we have fetched
-  // into
-  // the new frame as we make it, but let's not try that now.
+  // frames: FIXME: At some point we can try to splice in the frames we
+  // have fetched into the new frame as we make it, but let's not try that
+  // now.
   if (m_curr_frames_sp && m_curr_frames_sp->GetAllFramesFetched())
     m_prev_frames_sp.swap(m_curr_frames_sp);
   m_curr_frames_sp.reset();
@@ -1676,9 +1664,8 @@
     }
     SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextFunction);
 
-    // FIXME: ValueObject::Cast doesn't currently work correctly, at least not
-    // for scalars.
-    // Turn that back on when that works.
+    // FIXME: ValueObject::Cast doesn't currently work correctly, at least
+    // not for scalars. Turn that back on when that works.
     if (/* DISABLES CODE */ (0) && sc.function != nullptr) {
       Type *function_type = sc.function->GetType();
       if (function_type) {
@@ -1701,10 +1688,9 @@
       return return_error;
   }
 
-  // Now write the return registers for the chosen frame:
-  // Note, we can't use ReadAllRegisterValues->WriteAllRegisterValues, since the
-  // read & write
-  // cook their data
+  // Now write the return registers for the chosen frame: Note, we can't
+  // use ReadAllRegisterValues->WriteAllRegisterValues, since the read &
+  // write cook their data
 
   StackFrameSP youngest_frame_sp = thread->GetStackFrameAtIndex(0);
   if (youngest_frame_sp) {
@@ -1754,13 +1740,11 @@
   target->GetImages().FindAddressesForLine(target_sp, file, line, sc.function,
                                            within_function, outside_function);
 
-  // If possible, we try and stay within the current function.
-  // Within a function, we accept multiple locations (optimized code may do
-  // this,
-  // there's no solution here so we do the best we can).
-  // However if we're trying to leave the function, we don't know how to pick
-  // the
-  // right location, so if there's more than one then we bail.
+  // If possible, we try and stay within the current function. Within a
+  // function, we accept multiple locations (optimized code may do this,
+  // there's no solution here so we do the best we can). However if we're
+  // trying to leave the function, we don't know how to pick the right
+  // location, so if there's more than one then we bail.
   if (!within_function.empty())
     candidates = within_function;
   else if (outside_function.size() == 1 && can_leave_function)
@@ -1836,8 +1820,8 @@
 
 addr_t Thread::GetThreadLocalData(const ModuleSP module,
                                   lldb::addr_t tls_file_addr) {
-  // The default implementation is to ask the dynamic loader for it.
-  // This can be overridden for specific platforms.
+  // The default implementation is to ask the dynamic loader for it. This
+  // can be overridden for specific platforms.
   DynamicLoader *loader = GetProcess()->GetDynamicLoader();
   if (loader)
     return loader->GetThreadLocalData(module, shared_from_this(),
@@ -2095,11 +2079,10 @@
 }
 
 bool Thread::IsStillAtLastBreakpointHit() {
-  // If we are currently stopped at a breakpoint, always return that stopinfo
-  // and don't reset it.
-  // This allows threads to maintain their breakpoint stopinfo, such as when
-  // thread-stepping in
-  // multithreaded programs.
+  // If we are currently stopped at a breakpoint, always return that
+  // stopinfo and don't reset it. This allows threads to maintain their
+  // breakpoint stopinfo, such as when thread-stepping in multithreaded
+  // programs.
   if (m_stop_info_sp) {
     StopReason stop_reason = m_stop_info_sp->GetStopReason();
     if (stop_reason == lldb::eStopReasonBreakpoint) {
Index: source/Target/ThreadList.cpp
===================================================================
--- source/Target/ThreadList.cpp
+++ source/Target/ThreadList.cpp
@@ -54,9 +54,9 @@
 }
 
 ThreadList::~ThreadList() {
-  // Clear the thread list. Clear will take the mutex lock
-  // which will ensure that if anyone is using the list
-  // they won't get it removed while using it.
+  // Clear the thread list. Clear will take the mutex lock which will
+  // ensure that if anyone is using the list they won't get it removed
+  // while using it.
   Clear();
 }
 
@@ -232,12 +232,12 @@
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
   // The ShouldStop method of the threads can do a whole lot of work,
-  // figuring out whether the thread plan conditions are met.  So we don't want
-  // to keep the ThreadList locked the whole time we are doing this.
-  // FIXME: It is possible that running code could cause new threads
-  // to be created.  If that happens, we will miss asking them whether
-  // they should stop.  This is not a big deal since we haven't had
-  // a chance to hang any interesting operations on those threads yet.
+  // figuring out whether the thread plan conditions are met.  So we don't
+  // want to keep the ThreadList locked the whole time we are doing this.
+  // FIXME: It is possible that running code could cause new threads to be
+  // created.  If that happens, we will miss asking them whether they
+  // should stop.  This is not a big deal since we haven't had a chance to
+  // hang any interesting operations on those threads yet.
 
   collection threads_copy;
   {
@@ -246,26 +246,23 @@
 
     m_process->UpdateThreadListIfNeeded();
     for (lldb::ThreadSP thread_sp : m_threads) {
-      // This is an optimization...  If we didn't let a thread run in between
-      // the previous stop and this
-      // one, we shouldn't have to consult it for ShouldStop.  So just leave it
-      // off the list we are going to
-      // inspect.
-      // On Linux, if a thread-specific conditional breakpoint was hit, it won't
-      // necessarily be the thread
-      // that hit the breakpoint itself that evaluates the conditional
-      // expression, so the thread that hit
-      // the breakpoint could still be asked to stop, even though it hasn't been
-      // allowed to run since the
+      // This is an optimization...  If we didn't let a thread run in
+      // between the previous stop and this one, we shouldn't have to
+      // consult it for ShouldStop.  So just leave it off the list we are
+      // going to inspect. On Linux, if a thread-specific conditional
+      // breakpoint was hit, it won't necessarily be the thread that hit
+      // the breakpoint itself that evaluates the conditional expression,
+      // so the thread that hit the breakpoint could still be asked to
+      // stop, even though it hasn't been allowed to run since the
       // previous stop.
       if (thread_sp->GetTemporaryResumeState() != eStateSuspended ||
           thread_sp->IsStillAtLastBreakpointHit())
         threads_copy.push_back(thread_sp);
     }
 
-    // It is possible the threads we were allowing to run all exited and then
-    // maybe the user interrupted
-    // or something, then fall back on looking at all threads:
+    // It is possible the threads we were allowing to run all exited and
+    // then maybe the user interrupted or something, then fall back on
+    // looking at all threads:
 
     if (threads_copy.size() == 0)
       threads_copy = m_threads;
@@ -283,8 +280,8 @@
 
   bool did_anybody_stop_for_a_reason = false;
 
-  // If the event is an Interrupt event, then we're going to stop no matter
-  // what.  Otherwise, presume we won't stop.
+  // If the event is an Interrupt event, then we're going to stop no
+  // matter what.  Otherwise, presume we won't stop.
   bool should_stop = false;
   if (Process::ProcessEventData::GetInterruptedFromEvent(event_ptr)) {
     if (log)
@@ -295,13 +292,13 @@
     should_stop = true;
   }
 
-  // Now we run through all the threads and get their stop info's.  We want to
-  // make sure to do this first before
-  // we start running the ShouldStop, because one thread's ShouldStop could
-  // destroy information (like deleting a
-  // thread specific breakpoint another thread had stopped at) which could lead
-  // us to compute the StopInfo incorrectly.
-  // We don't need to use it here, we just want to make sure it gets computed.
+  // Now we run through all the threads and get their stop info's.  We
+  // want to make sure to do this first before we start running the
+  // ShouldStop, because one thread's ShouldStop could destroy information
+  // (like deleting a thread specific breakpoint another thread had
+  // stopped at) which could lead us to compute the StopInfo incorrectly.
+  // We don't need to use it here, we just want to make sure it gets
+  // computed.
 
   for (pos = threads_copy.begin(); pos != end; ++pos) {
     ThreadSP thread_sp(*pos);
@@ -311,28 +308,27 @@
   for (pos = threads_copy.begin(); pos != end; ++pos) {
     ThreadSP thread_sp(*pos);
 
-    // We should never get a stop for which no thread had a stop reason, but
-    // sometimes we do see this -
-    // for instance when we first connect to a remote stub.  In that case we
-    // should stop, since we can't figure out
-    // the right thing to do and stopping gives the user control over what to do
-    // in this instance.
+    // We should never get a stop for which no thread had a stop reason,
+    // but sometimes we do see this - for instance when we first connect
+    // to a remote stub.  In that case we should stop, since we can't
+    // figure out the right thing to do and stopping gives the user
+    // control over what to do in this instance.
     //
-    // Note, this causes a problem when you have a thread specific breakpoint,
-    // and a bunch of threads hit the breakpoint,
-    // but not the thread which we are waiting for.  All the threads that are
-    // not "supposed" to hit the breakpoint
-    // are marked as having no stop reason, which is right, they should not show
-    // a stop reason.  But that triggers this
-    // code and causes us to stop seemingly for no reason.
+    // Note, this causes a problem when you have a thread specific
+    // breakpoint, and a bunch of threads hit the breakpoint, but not the
+    // thread which we are waiting for.  All the threads that are not
+    // "supposed" to hit the breakpoint are marked as having no stop
+    // reason, which is right, they should not show a stop reason.  But
+    // that triggers this code and causes us to stop seemingly for no
+    // reason.
     //
-    // Since the only way we ever saw this error was on first attach, I'm only
-    // going to trigger set did_anybody_stop_for_a_reason
-    // to true unless this is the first stop.
+    // Since the only way we ever saw this error was on first attach, I'm
+    // only going to trigger set did_anybody_stop_for_a_reason to true
+    // unless this is the first stop.
     //
-    // If this becomes a problem, we'll have to have another StopReason like
-    // "StopInfoHidden" which will look invalid
-    // everywhere but at this check.
+    // If this becomes a problem, we'll have to have another StopReason
+    // like "StopInfoHidden" which will look invalid everywhere but at
+    // this check.
 
     if (thread_sp->GetProcess()->GetStopID() > 1)
       did_anybody_stop_for_a_reason = true;
@@ -380,8 +376,8 @@
                 (uint64_t)m_threads.size());
 
   // Run through the threads and ask whether we should report this event.
-  // For stopping, a YES vote wins over everything.  A NO vote wins over NO
-  // opinion.
+  // For stopping, a YES vote wins over everything.  A NO vote wins over
+  // NO opinion.
   for (pos = m_threads.begin(); pos != end; ++pos) {
     ThreadSP thread_sp(*pos);
     const Vote vote = thread_sp->ShouldReportStop(event_ptr);
@@ -428,7 +424,8 @@
   collection::iterator pos, end = m_threads.end();
 
   // Run through the threads and ask whether we should report this event.
-  // The rule is NO vote wins over everything, a YES vote wins over no opinion.
+  // The rule is NO vote wins over everything, a YES vote wins over no
+  // opinion.
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
@@ -495,24 +492,21 @@
 }
 
 bool ThreadList::WillResume() {
-  // Run through the threads and perform their momentary actions.
-  // But we only do this for threads that are running, user suspended
-  // threads stay where they are.
+  // Run through the threads and perform their momentary actions. But we
+  // only do this for threads that are running, user suspended threads
+  // stay where they are.
 
   std::lock_guard<std::recursive_mutex> guard(GetMutex());
   m_process->UpdateThreadListIfNeeded();
 
   collection::iterator pos, end = m_threads.end();
 
-  // See if any thread wants to run stopping others.  If it does, then we won't
-  // setup the other threads for resume, since they aren't going to get a chance
-  // to run.  This is necessary because the SetupForResume might add
-  // "StopOthers"
-  // plans which would then get to be part of the who-gets-to-run negotiation,
-  // but
-  // they're coming in after the fact, and the threads that are already set up
-  // should
-  // take priority.
+  // See if any thread wants to run stopping others.  If it does, then we
+  // won't setup the other threads for resume, since they aren't going to
+  // get a chance to run.  This is necessary because the SetupForResume
+  // might add "StopOthers" plans which would then get to be part of the
+  // who-gets-to-run negotiation, but they're coming in after the fact,
+  // and the threads that are already set up should take priority.
 
   bool wants_solo_run = false;
 
@@ -543,12 +537,11 @@
     m_process->StopNoticingNewThreads();
   }
 
-  // Give all the threads that are likely to run a last chance to set up their
-  // state before we
-  // negotiate who is actually going to get a chance to run...
-  // Don't set to resume suspended threads, and if any thread wanted to stop
-  // others, only
-  // call setup on the threads that request StopOthers...
+  // Give all the threads that are likely to run a last chance to set up
+  // their state before we negotiate who is actually going to get a chance
+  // to run... Don't set to resume suspended threads, and if any thread
+  // wanted to stop others, only call setup on the threads that request
+  // StopOthers...
 
   for (pos = m_threads.begin(); pos != end; ++pos) {
     if ((*pos)->GetResumeState() != eStateSuspended &&
@@ -560,8 +553,8 @@
     }
   }
 
-  // Now go through the threads and see if any thread wants to run just itself.
-  // if so then pick one and run it.
+  // Now go through the threads and see if any thread wants to run just
+  // itself. if so then pick one and run it.
 
   ThreadList run_me_only_list(m_process);
 
@@ -577,12 +570,13 @@
           !(*pos)->GetBackingThread())
         continue;
 
-      // You can't say "stop others" and also want yourself to be suspended.
+      // You can't say "stop others" and also want yourself to be
+      // suspended.
       assert(thread_sp->GetCurrentPlan()->RunState() != eStateSuspended);
 
       if (thread_sp == GetSelectedThread()) {
-        // If the currently selected thread wants to run on its own, always let
-        // it.
+        // If the currently selected thread wants to run on its own,
+        // always let it.
         run_only_current_thread = true;
         run_me_only_list.Clear();
         run_me_only_list.AddThread(thread_sp);
@@ -638,8 +632,8 @@
   std::lock_guard<std::recursive_mutex> guard(GetMutex());
   collection::iterator pos, end = m_threads.end();
   for (pos = m_threads.begin(); pos != end; ++pos) {
-    // Don't clear out threads that aren't going to get a chance to run, rather
-    // leave their state for the next time around.
+    // Don't clear out threads that aren't going to get a chance to run,
+    // rather leave their state for the next time around.
     ThreadSP thread_sp(*pos);
     if (thread_sp->GetResumeState() != eStateSuspended)
       thread_sp->DidResume();
@@ -650,14 +644,13 @@
   std::lock_guard<std::recursive_mutex> guard(GetMutex());
   collection::iterator pos, end = m_threads.end();
   for (pos = m_threads.begin(); pos != end; ++pos) {
-    // Notify threads that the process just stopped.
-    // Note, this currently assumes that all threads in the list
-    // stop when the process stops.  In the future we will want to support
-    // a debugging model where some threads continue to run while others
-    // are stopped.  We either need to handle that somehow here or
-    // create a special thread list containing only threads which will
-    // stop in the code that calls this method (currently
-    // Process::SetPrivateState).
+    // Notify threads that the process just stopped. Note, this currently
+    // assumes that all threads in the list stop when the process stops.
+    // In the future we will want to support a debugging model where some
+    // threads continue to run while others are stopped.  We either need
+    // to handle that somehow here or create a special thread list
+    // containing only threads which will stop in the code that calls this
+    // method (currently Process::SetPrivateState).
     ThreadSP thread_sp(*pos);
     if (StateIsRunningState(thread_sp->GetState()))
       thread_sp->DidStop();
@@ -726,13 +719,12 @@
     m_threads.swap(rhs.m_threads);
     m_selected_tid = rhs.m_selected_tid;
 
-    // Now we look for threads that we are done with and
-    // make sure to clear them up as much as possible so
-    // anyone with a shared pointer will still have a reference,
-    // but the thread won't be of much use. Using std::weak_ptr
-    // for all backward references (such as a thread to a process)
-    // will eventually solve this issue for us, but for now, we
-    // need to work around the issue
+    // Now we look for threads that we are done with and make sure to
+    // clear them up as much as possible so anyone with a shared pointer
+    // will still have a reference, but the thread won't be of much use.
+    // Using std::weak_ptr for all backward references (such as a thread
+    // to a process) will eventually solve this issue for us, but for now,
+    // we need to work around the issue
     collection::iterator rhs_pos, rhs_end = rhs.m_threads.end();
     for (rhs_pos = rhs.m_threads.begin(); rhs_pos != rhs_end; ++rhs_pos) {
       const lldb::tid_t tid = (*rhs_pos)->GetID();
Index: source/Target/ThreadPlanBase.cpp
===================================================================
--- source/Target/ThreadPlanBase.cpp
+++ source/Target/ThreadPlanBase.cpp
@@ -28,9 +28,9 @@
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
-// ThreadPlanBase: This one always stops, and never has anything particular
-// to do.
-// FIXME: The "signal handling" policies should probably go here.
+// ThreadPlanBase: This one always stops, and never has anything
+// particular to do. FIXME: The "signal handling" policies should probably
+// go here.
 //----------------------------------------------------------------------
 
 ThreadPlanBase::ThreadPlanBase(Thread &thread)
@@ -59,8 +59,8 @@
 bool ThreadPlanBase::ValidatePlan(Stream *error) { return true; }
 
 bool ThreadPlanBase::DoPlanExplainsStop(Event *event_ptr) {
-  // The base plan should defer to its tracer, since by default it
-  // always handles the stop.
+  // The base plan should defer to its tracer, since by default it always
+  // handles the stop.
   if (TracerExplainsStop())
     return false;
   else
@@ -99,10 +99,9 @@
     case eStopReasonBreakpoint:
     case eStopReasonWatchpoint:
       if (stop_info_sp->ShouldStopSynchronous(event_ptr)) {
-        // If we are going to stop for a breakpoint, then unship the other plans
-        // at this point.  Don't force the discard, however, so Master plans can
-        // stay
-        // in place if they want to.
+        // If we are going to stop for a breakpoint, then unship the other
+        // plans at this point.  Don't force the discard, however, so
+        // Master plans can stay in place if they want to.
         if (log)
           log->Printf(
               "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
@@ -111,12 +110,11 @@
         m_thread.DiscardThreadPlans(false);
         return true;
       }
-      // If we aren't going to stop at this breakpoint, and it is internal,
-      // don't report this stop or the subsequent running event.
-      // Otherwise we will post the stopped & running, but the stopped event
-      // will get marked
-      // with "restarted" so the UI will know to wait and expect the consequent
-      // "running".
+      // If we aren't going to stop at this breakpoint, and it is
+      // internal, don't report this stop or the subsequent running event.
+      // Otherwise we will post the stopped & running, but the stopped
+      // event will get marked with "restarted" so the UI will know to
+      // wait and expect the consequent "running".
       if (stop_info_sp->ShouldNotify(event_ptr)) {
         m_stop_vote = eVoteYes;
         m_run_vote = eVoteYes;
@@ -131,10 +129,9 @@
       break;
 
     case eStopReasonException:
-      // If we crashed, discard thread plans and stop.  Don't force the discard,
-      // however,
-      // since on rerun the target may clean up this exception and continue
-      // normally from there.
+      // If we crashed, discard thread plans and stop.  Don't force the
+      // discard, however, since on rerun the target may clean up this
+      // exception and continue normally from there.
       if (log)
         log->Printf(
             "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
@@ -144,10 +141,9 @@
       return true;
 
     case eStopReasonExec:
-      // If we crashed, discard thread plans and stop.  Don't force the discard,
-      // however,
-      // since on rerun the target may clean up this exception and continue
-      // normally from there.
+      // If we crashed, discard thread plans and stop.  Don't force the
+      // discard, however, since on rerun the target may clean up this
+      // exception and continue normally from there.
       if (log)
         log->Printf(
             "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
@@ -167,8 +163,8 @@
         m_thread.DiscardThreadPlans(false);
         return true;
       } else {
-        // We're not going to stop, but while we are here, let's figure out
-        // whether to report this.
+        // We're not going to stop, but while we are here, let's figure
+        // out whether to report this.
         if (stop_info_sp->ShouldNotify(event_ptr))
           m_stop_vote = eVoteYes;
         else
@@ -197,9 +193,8 @@
 
 bool ThreadPlanBase::DoWillResume(lldb::StateType resume_state,
                                   bool current_plan) {
-  // Reset these to the default values so we don't set them wrong, then not get
-  // asked
-  // for a while, then return the wrong answer.
+  // Reset these to the default values so we don't set them wrong, then
+  // not get asked for a while, then return the wrong answer.
   m_run_vote = eVoteNoOpinion;
   m_stop_vote = eVoteNo;
   return true;
Index: source/Target/ThreadPlanCallFunction.cpp
===================================================================
--- source/Target/ThreadPlanCallFunction.cpp
+++ source/Target/ThreadPlanCallFunction.cpp
@@ -55,9 +55,8 @@
   SetBreakpoints();
 
   m_function_sp = thread.GetRegisterContext()->GetSP() - abi->GetRedZoneSize();
-  // If we can't read memory at the point of the process where we are planning
-  // to put our function, we're
-  // not going to get any further...
+  // If we can't read memory at the point of the process where we are
+  // planning to put our function, we're not going to get any further...
   Status error;
   process_sp->ReadUnsignedIntegerFromMemory(m_function_sp, 4, 0, error);
   if (!error.Success()) {
@@ -278,9 +277,8 @@
                                                   LIBLLDB_LOG_PROCESS));
   m_real_stop_info_sp = GetPrivateStopInfo();
 
-  // If our subplan knows why we stopped, even if it's done (which would forward
-  // the question to us)
-  // we answer yes.
+  // If our subplan knows why we stopped, even if it's done (which would
+  // forward the question to us) we answer yes.
   if (m_subplan_sp && m_subplan_sp->PlanExplainsStop(event_ptr)) {
     SetPlanComplete();
     return true;
@@ -301,19 +299,19 @@
   if (stop_reason == eStopReasonBreakpoint && BreakpointsExplainStop())
     return true;
 
-  // One more quirk here.  If this event was from Halt interrupting the target,
-  // then we should not consider
-  // ourselves complete.  Return true to acknowledge the stop.
+  // One more quirk here.  If this event was from Halt interrupting the
+  // target, then we should not consider ourselves complete.  Return true
+  // to acknowledge the stop.
   if (Process::ProcessEventData::GetInterruptedFromEvent(event_ptr)) {
     if (log)
       log->Printf("ThreadPlanCallFunction::PlanExplainsStop: The event is an "
                   "Interrupt, returning true.");
     return true;
   }
-  // We control breakpoints separately from other "stop reasons."  So first,
-  // check the case where we stopped for an internal breakpoint, in that case,
-  // continue on.
-  // If it is not an internal breakpoint, consult m_ignore_breakpoints.
+  // We control breakpoints separately from other "stop reasons."  So
+  // first, check the case where we stopped for an internal breakpoint, in
+  // that case, continue on. If it is not an internal breakpoint, consult
+  // m_ignore_breakpoints.
 
   if (stop_reason == eStopReasonBreakpoint) {
     ProcessSP process_sp(m_thread.CalculateProcess());
@@ -360,19 +358,17 @@
       return false;
     }
   } else if (!m_unwind_on_error) {
-    // If we don't want to discard this plan, than any stop we don't understand
-    // should be propagated up the stack.
+    // If we don't want to discard this plan, than any stop we don't
+    // understand should be propagated up the stack.
     return false;
   } else {
-    // If the subplan is running, any crashes are attributable to us.
-    // If we want to discard the plan, then we say we explain the stop
-    // but if we are going to be discarded, let whoever is above us
-    // explain the stop.
-    // But don't discard the plan if the stop would restart itself (for instance
-    // if it is a
-    // signal that is set not to stop.  Check that here first.  We just say we
-    // explain the stop
-    // but aren't done and everything will continue on from there.
+    // If the subplan is running, any crashes are attributable to us. If
+    // we want to discard the plan, then we say we explain the stop but if
+    // we are going to be discarded, let whoever is above us explain the
+    // stop. But don't discard the plan if the stop would restart itself
+    // (for instance if it is a signal that is set not to stop.  Check
+    // that here first.  We just say we explain the stop but aren't done
+    // and everything will continue on from there.
 
     if (m_real_stop_info_sp &&
         m_real_stop_info_sp->ShouldStopSynchronous(event_ptr)) {
@@ -384,9 +380,9 @@
 }
 
 bool ThreadPlanCallFunction::ShouldStop(Event *event_ptr) {
-  // We do some computation in DoPlanExplainsStop that may or may not set the
-  // plan as complete.
-  // We need to do that here to make sure our state is correct.
+  // We do some computation in DoPlanExplainsStop that may or may not set
+  // the plan as complete. We need to do that here to make sure our state
+  // is correct.
   DoPlanExplainsStop(event_ptr);
 
   if (IsPlanComplete()) {
@@ -405,9 +401,8 @@
   //#define SINGLE_STEP_EXPRESSIONS
 
   // Now set the thread state to "no reason" so we don't run with whatever
-  // signal was outstanding...
-  // Wait till the plan is pushed so we aren't changing the stop info till we're
-  // about to run.
+  // signal was outstanding... Wait till the plan is pushed so we aren't
+  // changing the stop info till we're about to run.
 
   GetThread().SetStopInfoToNothing();
 
@@ -483,10 +478,10 @@
 
       SetPlanComplete(false);
 
-      // If the user has set the ObjC language breakpoint, it would normally get
-      // priority over our internal
-      // catcher breakpoint, but in this case we can't let that happen, so force
-      // the ShouldStop here.
+      // If the user has set the ObjC language breakpoint, it would
+      // normally get priority over our internal catcher breakpoint, but
+      // in this case we can't let that happen, so force the ShouldStop
+      // here.
       stop_info_sp->OverrideShouldStop(true);
       return true;
     }
Index: source/Target/ThreadPlanCallFunctionUsingABI.cpp
===================================================================
--- source/Target/ThreadPlanCallFunctionUsingABI.cpp
+++ source/Target/ThreadPlanCallFunctionUsingABI.cpp
@@ -24,8 +24,8 @@
 using namespace lldb_private;
 
 //--------------------------------------------------------------------------------------------
-// ThreadPlanCallFunctionUsingABI: Plan to call a single function using the ABI
-// instead of JIT
+// ThreadPlanCallFunctionUsingABI: Plan to call a single function using
+// the ABI instead of JIT
 //-------------------------------------------------------------------------------------------
 ThreadPlanCallFunctionUsingABI::ThreadPlanCallFunctionUsingABI(
     Thread &thread, const Address &function, llvm::Type &prototype,
Index: source/Target/ThreadPlanCallOnFunctionExit.cpp
===================================================================
--- source/Target/ThreadPlanCallOnFunctionExit.cpp
+++ source/Target/ThreadPlanCallOnFunctionExit.cpp
@@ -23,8 +23,8 @@
 }
 
 void ThreadPlanCallOnFunctionExit::DidPush() {
-  // We now want to queue the "step out" thread plan so it executes
-  // and completes.
+  // We now want to queue the "step out" thread plan so it executes and
+  // completes.
 
   // Set stop vote to eVoteNo.
   m_step_out_threadplan_sp = GetThread().QueueThreadPlanForStepOut(
@@ -60,8 +60,8 @@
 
 bool ThreadPlanCallOnFunctionExit::ShouldStop(Event *event_ptr) {
   // If this is where we find out that an internal stop came in, then:
-  // Check if the step-out plan completed.  If it did, then we want to
-  // run the callback here (our reason for living...)
+  // Check if the step-out plan completed.  If it did, then we want to run
+  // the callback here (our reason for living...)
   if (m_step_out_threadplan_sp && m_step_out_threadplan_sp->IsPlanComplete()) {
     m_callback();
 
@@ -71,8 +71,8 @@
     // Indicate that this plan is done and can be discarded.
     SetPlanComplete();
 
-    // We're done now, but we want to return false so that we
-    // don't cause the thread to really stop.
+    // We're done now, but we want to return false so that we don't cause
+    // the thread to really stop.
   }
 
   return false;
@@ -80,16 +80,15 @@
 
 bool ThreadPlanCallOnFunctionExit::WillStop() {
   // The code looks like the return value is ignored via ThreadList::
-  // ShouldStop().
-  // This is called when we really are going to stop.  We don't care
-  // and don't need to do anything here.
+  // ShouldStop(). This is called when we really are going to stop.  We
+  // don't care and don't need to do anything here.
   return false;
 }
 
 bool ThreadPlanCallOnFunctionExit::DoPlanExplainsStop(Event *event_ptr) {
-  // We don't ever explain a stop.  The only stop that is relevant
-  // to us directly is the step_out plan we added to do the heavy lifting
-  // of getting us past the current method.
+  // We don't ever explain a stop.  The only stop that is relevant to us
+  // directly is the step_out plan we added to do the heavy lifting of
+  // getting us past the current method.
   return false;
 }
 
Index: source/Target/ThreadPlanCallUserExpression.cpp
===================================================================
--- source/Target/ThreadPlanCallUserExpression.cpp
+++ source/Target/ThreadPlanCallUserExpression.cpp
@@ -44,8 +44,8 @@
     lldb::UserExpressionSP &user_expression_sp)
     : ThreadPlanCallFunction(thread, function, CompilerType(), args, options),
       m_user_expression_sp(user_expression_sp) {
-  // User expressions are generally "User generated" so we should set them up to
-  // stop when done.
+  // User expressions are generally "User generated" so we should set them
+  // up to stop when done.
   SetIsMasterPlan(true);
   SetOkayToDiscard(false);
 }
Index: source/Target/ThreadPlanPython.cpp
===================================================================
--- source/Target/ThreadPlanPython.cpp
+++ source/Target/ThreadPlanPython.cpp
@@ -42,15 +42,14 @@
 }
 
 ThreadPlanPython::~ThreadPlanPython() {
-  // FIXME, do I need to decrement the ref count on this implementation object
-  // to make it go away?
+  // FIXME, do I need to decrement the ref count on this implementation
+  // object to make it go away?
 }
 
 bool ThreadPlanPython::ValidatePlan(Stream *error) {
-  // I have to postpone setting up the implementation till after the constructor
-  // because I need to call
-  // shared_from_this, which you can't do in the constructor.  So I'll do it
-  // here.
+  // I have to postpone setting up the implementation till after the
+  // constructor because I need to call shared_from_this, which you can't
+  // do in the constructor.  So I'll do it here.
   if (m_implementation_sp)
     return true;
   else
@@ -58,9 +57,9 @@
 }
 
 void ThreadPlanPython::DidPush() {
-  // We set up the script side in DidPush, so that it can push other plans in
-  // the constructor,
-  // and doesn't have to care about the details of DidPush.
+  // We set up the script side in DidPush, so that it can push other plans
+  // in the constructor, and doesn't have to care about the details of
+  // DidPush.
 
   if (!m_class_name.empty()) {
     ScriptInterpreter *script_interp = m_thread.GetProcess()
@@ -154,8 +153,8 @@
                 m_class_name.c_str());
   bool mischief_managed = true;
   if (m_implementation_sp) {
-    // I don't really need mischief_managed, since it's simpler to just call
-    // SetPlanComplete in should_stop.
+    // I don't really need mischief_managed, since it's simpler to just
+    // call SetPlanComplete in should_stop.
     mischief_managed = IsPlanComplete();
     if (mischief_managed)
       m_implementation_sp.reset();
@@ -187,8 +186,8 @@
 // The ones below are not currently exported to Python.
 
 bool ThreadPlanPython::StopOthers() {
-  // For now Python plans run all threads, but we should add some controls for
-  // this.
+  // For now Python plans run all threads, but we should add some controls
+  // for this.
   return false;
 }
 
Index: source/Target/ThreadPlanShouldStopHere.cpp
===================================================================
--- source/Target/ThreadPlanShouldStopHere.cpp
+++ source/Target/ThreadPlanShouldStopHere.cpp
@@ -85,9 +85,8 @@
 
   // Always avoid code with line number 0.
   // FIXME: At present the ShouldStop and the StepFromHere calculate this
-  // independently.  If this ever
-  // becomes expensive (this one isn't) we can try to have this set a state that
-  // the StepFromHere can use.
+  // independently.  If this ever becomes expensive (this one isn't) we
+  // can try to have this set a state that the StepFromHere can use.
   if (frame) {
     SymbolContext sc;
     sc = frame->GetSymbolContext(eSymbolContextLineEntry);
@@ -104,9 +103,8 @@
   const bool stop_others = false;
   const size_t frame_index = 0;
   ThreadPlanSP return_plan_sp;
-  // If we are stepping through code at line number 0, then we need to step over
-  // this range.  Otherwise
-  // we will step out.
+  // If we are stepping through code at line number 0, then we need to
+  // step over this range.  Otherwise we will step out.
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
   StackFrame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get();
@@ -118,9 +116,8 @@
   if (sc.line_entry.line == 0) {
     AddressRange range = sc.line_entry.range;
 
-    // If the whole function is marked line 0 just step out, that's easier &
-    // faster than continuing
-    // to step through it.
+    // If the whole function is marked line 0 just step out, that's easier
+    // & faster than continuing to step through it.
     bool just_step_out = false;
     if (sc.symbol && sc.symbol->ValueIsAddress()) {
       Address symbol_end = sc.symbol->GetAddress();
Index: source/Target/ThreadPlanStepInRange.cpp
===================================================================
--- source/Target/ThreadPlanStepInRange.cpp
+++ source/Target/ThreadPlanStepInRange.cpp
@@ -34,9 +34,8 @@
     ThreadPlanShouldStopHere::eStepInAvoidNoDebug;
 
 //----------------------------------------------------------------------
-// ThreadPlanStepInRange: Step through a stack range, either stepping over or
-// into
-// based on the value of \a type.
+// ThreadPlanStepInRange: Step through a stack range, either stepping over
+// or into based on the value of \a type.
 //----------------------------------------------------------------------
 
 ThreadPlanStepInRange::ThreadPlanStepInRange(
@@ -163,16 +162,15 @@
   }
 
   if (m_virtual_step) {
-    // If we've just completed a virtual step, all we need to do is check for a
-    // ShouldStopHere plan, and otherwise
-    // we're done.
-    // FIXME - This can be both a step in and a step out.  Probably should
-    // record which in the m_virtual_step.
+    // If we've just completed a virtual step, all we need to do is check
+    // for a ShouldStopHere plan, and otherwise we're done. FIXME - This
+    // can be both a step in and a step out.  Probably should record which
+    // in the m_virtual_step.
     m_sub_plan_sp = CheckShouldStopHereAndQueueStepOut(eFrameCompareYounger);
   } else {
-    // Stepping through should be done running other threads in general, since
-    // we're setting a breakpoint and
-    // continuing.  So only stop others if we are explicitly told to do so.
+    // Stepping through should be done running other threads in general,
+    // since we're setting a breakpoint and continuing.  So only stop
+    // others if we are explicitly told to do so.
 
     bool stop_others = (m_stop_others == lldb::eOnlyThisThread);
 
@@ -182,11 +180,10 @@
         frame_order == eFrameCompareSameParent) {
       // If we're in an older frame then we should stop.
       //
-      // A caveat to this is if we think the frame is older but we're actually
-      // in a trampoline.
-      // I'm going to make the assumption that you wouldn't RETURN to a
-      // trampoline.  So if we are
-      // in a trampoline we think the frame is older because the trampoline
+      // A caveat to this is if we think the frame is older but we're
+      // actually in a trampoline. I'm going to make the assumption that
+      // you wouldn't RETURN to a trampoline.  So if we are in a
+      // trampoline we think the frame is older because the trampoline
       // confused the backtracer.
       m_sub_plan_sp = m_thread.QueueThreadPlanForStepThrough(m_stack_id, false,
                                                              stop_others);
@@ -204,19 +201,15 @@
             "Thought I stepped out, but in fact arrived at a trampoline.");
       }
     } else if (frame_order == eFrameCompareEqual && InSymbol()) {
-      // If we are not in a place we should step through, we're done.
-      // One tricky bit here is that some stubs don't push a frame, so we have
-      // to check
-      // both the case of a frame that is younger, or the same as this frame.
-      // However, if the frame is the same, and we are still in the symbol we
-      // started
-      // in, the we don't need to do this.  This first check isn't strictly
-      // necessary,
-      // but it is more efficient.
-
-      // If we're still in the range, keep going, either by running to the next
-      // branch breakpoint, or by
-      // stepping.
+      // If we are not in a place we should step through, we're done. One
+      // tricky bit here is that some stubs don't push a frame, so we have
+      // to check both the case of a frame that is younger, or the same as
+      // this frame. However, if the frame is the same, and we are still
+      // in the symbol we started in, the we don't need to do this.  This
+      // first check isn't strictly necessary, but it is more efficient.
+
+      // If we're still in the range, keep going, either by running to the
+      // next branch breakpoint, or by stepping.
       if (InRange()) {
         SetNextBranchBreakpoint();
         return false;
@@ -227,8 +220,8 @@
       return true;
     }
 
-    // If we get to this point, we're not going to use a previously set "next
-    // branch" breakpoint, so delete it:
+    // If we get to this point, we're not going to use a previously set
+    // "next branch" breakpoint, so delete it:
     ClearNextBranchBreakpoint();
 
     // We may have set the plan up above in the FrameIsOlder section:
@@ -244,15 +237,14 @@
         log->Printf("No step through plan found.");
     }
 
-    // If not, give the "should_stop" callback a chance to push a plan to get us
-    // out of here.
-    // But only do that if we actually have stepped in.
+    // If not, give the "should_stop" callback a chance to push a plan to
+    // get us out of here. But only do that if we actually have stepped
+    // in.
     if (!m_sub_plan_sp && frame_order == eFrameCompareYounger)
       m_sub_plan_sp = CheckShouldStopHereAndQueueStepOut(frame_order);
 
-    // If we've stepped in and we are going to stop here, check to see if we
-    // were asked to
-    // run past the prologue, and if so do that.
+    // If we've stepped in and we are going to stop here, check to see if
+    // we were asked to run past the prologue, and if so do that.
 
     if (!m_sub_plan_sp && frame_order == eFrameCompareYounger &&
         m_step_past_prologue) {
@@ -398,8 +390,8 @@
   StackFrame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
-  // First see if the ThreadPlanShouldStopHere default implementation thinks we
-  // should get out of here:
+  // First see if the ThreadPlanShouldStopHere default implementation
+  // thinks we should get out of here:
   should_stop_here = ThreadPlanShouldStopHere::DefaultShouldStopHereCallback(
       current_plan, flags, operation, baton);
   if (!should_stop_here)
@@ -413,8 +405,8 @@
       SymbolContext sc = frame->GetSymbolContext(
           eSymbolContextFunction | eSymbolContextBlock | eSymbolContextSymbol);
       if (sc.symbol != nullptr) {
-        // First try an exact match, since that's cheap with ConstStrings.  Then
-        // do a strstr compare.
+        // First try an exact match, since that's cheap with ConstStrings.
+        // Then do a strstr compare.
         if (step_in_range_plan->m_step_into_target == sc.GetFunctionName()) {
           should_stop_here = true;
         } else {
@@ -448,26 +440,20 @@
 }
 
 bool ThreadPlanStepInRange::DoPlanExplainsStop(Event *event_ptr) {
-  // We always explain a stop.  Either we've just done a single step, in which
-  // case we'll do our ordinary processing, or we stopped for some
-  // reason that isn't handled by our sub-plans, in which case we want to just
-  // stop right
-  // away.
-  // In general, we don't want to mark the plan as complete for unexplained
-  // stops.
-  // For instance, if you step in to some code with no debug info, so you step
-  // out
-  // and in the course of that hit a breakpoint, then you want to stop & show
-  // the user
-  // the breakpoint, but not unship the step in plan, since you still may want
-  // to complete that
-  // plan when you continue.  This is particularly true when doing "step in to
-  // target function."
-  // stepping.
+  // We always explain a stop.  Either we've just done a single step, in
+  // which case we'll do our ordinary processing, or we stopped for some
+  // reason that isn't handled by our sub-plans, in which case we want to
+  // just stop right away. In general, we don't want to mark the plan as
+  // complete for unexplained stops. For instance, if you step in to some
+  // code with no debug info, so you step out and in the course of that
+  // hit a breakpoint, then you want to stop & show the user the
+  // breakpoint, but not unship the step in plan, since you still may want
+  // to complete that plan when you continue.  This is particularly true
+  // when doing "step in to target function." stepping.
   //
-  // The only variation is that if we are doing "step by running to next branch"
-  // in which case
-  // if we hit our branch breakpoint we don't set the plan to complete.
+  // The only variation is that if we are doing "step by running to next
+  // branch" in which case if we hit our branch breakpoint we don't set
+  // the plan to complete.
 
   bool return_value = false;
 
@@ -512,9 +498,9 @@
                     m_thread.GetCurrentInlinedDepth());
       SetStopInfo(StopInfo::CreateStopReasonToTrace(m_thread));
 
-      // FIXME: Maybe it would be better to create a InlineStep stop reason, but
-      // then
-      // the whole rest of the world would have to handle that stop reason.
+      // FIXME: Maybe it would be better to create a InlineStep stop
+      // reason, but then the whole rest of the world would have to handle
+      // that stop reason.
       m_virtual_step = true;
     }
     return !step_without_resume;
Index: source/Target/ThreadPlanStepInstruction.cpp
===================================================================
--- source/Target/ThreadPlanStepInstruction.cpp
+++ source/Target/ThreadPlanStepInstruction.cpp
@@ -105,9 +105,9 @@
     }
     return (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr);
   } else if (cur_frame_id < m_stack_id) {
-    // If the current frame is younger than the start frame and we are stepping
-    // over, then we need to continue,
-    // but if we are doing just one step, we're done.
+    // If the current frame is younger than the start frame and we are
+    // stepping over, then we need to continue, but if we are doing just
+    // one step, we're done.
     return !m_step_over;
   } else {
     if (log) {
@@ -140,8 +140,7 @@
           return true;
         } else {
           // We are still stepping, reset the start pc, and in case we've
-          // stepped out,
-          // reset the current stack id.
+          // stepped out, reset the current stack id.
           SetUpState();
           return false;
         }
@@ -153,10 +152,9 @@
       if (return_frame) {
         if (return_frame->GetStackID() != m_parent_frame_id ||
             m_start_has_symbol) {
-          // next-instruction shouldn't step out of inlined functions.  But we
-          // may have stepped into a
-          // real function that starts with an inlined function, and we do want
-          // to step out of that...
+          // next-instruction shouldn't step out of inlined functions.
+          // But we may have stepped into a real function that starts with
+          // an inlined function, and we do want to step out of that...
 
           if (cur_frame_sp->IsInlined()) {
             StackFrameSP parent_frame_sp =
@@ -190,9 +188,8 @@
             log->Printf("%s.", s.GetData());
           }
 
-          // StepInstruction should probably have the tri-state RunMode, but for
-          // now it is safer to
-          // run others.
+          // StepInstruction should probably have the tri-state RunMode,
+          // but for now it is safer to run others.
           const bool stop_others = false;
           m_thread.QueueThreadPlanForStepOutNoShouldStop(
               false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion, 0);
@@ -221,9 +218,8 @@
         SetPlanComplete();
         return true;
       } else {
-        // We are still stepping, reset the start pc, and in case we've stepped
-        // in or out,
-        // reset the current stack id.
+        // We are still stepping, reset the start pc, and in case we've
+        // stepped in or out, reset the current stack id.
         SetUpState();
         return false;
       }
Index: source/Target/ThreadPlanStepOut.cpp
===================================================================
--- source/Target/ThreadPlanStepOut.cpp
+++ source/Target/ThreadPlanStepOut.cpp
@@ -63,17 +63,15 @@
   m_step_out_to_id = return_frame_sp->GetStackID();
   m_immediate_step_from_id = immediate_return_from_sp->GetStackID();
 
-  // If the frame directly below the one we are returning to is inlined, we have
-  // to be
-  // a little more careful.  It is non-trivial to determine the real "return
-  // code address" for
-  // an inlined frame, so we have to work our way to that frame and then step
-  // out.
+  // If the frame directly below the one we are returning to is inlined,
+  // we have to be a little more careful.  It is non-trivial to determine
+  // the real "return code address" for an inlined frame, so we have to
+  // work our way to that frame and then step out.
   if (immediate_return_from_sp && immediate_return_from_sp->IsInlined()) {
     if (frame_idx > 0) {
-      // First queue a plan that gets us to this inlined frame, and when we get
-      // there we'll queue a second
-      // plan that walks us out of this frame.
+      // First queue a plan that gets us to this inlined frame, and when
+      // we get there we'll queue a second plan that walks us out of this
+      // frame.
       m_step_out_to_inline_plan_sp.reset(new ThreadPlanStepOut(
           m_thread, nullptr, false, stop_others, eVoteNoOpinion, eVoteNoOpinion,
           frame_idx - 1, eLazyBoolNo, continue_to_next_branch));
@@ -81,13 +79,13 @@
           ->SetShouldStopHereCallbacks(nullptr, nullptr);
       m_step_out_to_inline_plan_sp->SetPrivate(true);
     } else {
-      // If we're already at the inlined frame we're stepping through, then just
-      // do that now.
+      // If we're already at the inlined frame we're stepping through,
+      // then just do that now.
       QueueInlinedStepPlan(false);
     }
   } else if (return_frame_sp) {
-    // Find the return address and set a breakpoint there:
-    // FIXME - can we do this more securely if we know first_insn?
+    // Find the return address and set a breakpoint there: FIXME - can we
+    // do this more securely if we know first_insn?
 
     Address return_address(return_frame_sp->GetFrameCodeAddress());
     if (continue_to_next_branch) {
@@ -185,9 +183,8 @@
         s->Printf("address 0x%" PRIx64 "", (uint64_t)m_step_from_insn);
       }
 
-      // FIXME: find some useful way to present the m_return_id, since there may
-      // be multiple copies of the
-      // same function on the stack.
+      // FIXME: find some useful way to present the m_return_id, since
+      // there may be multiple copies of the same function on the stack.
 
       s->Printf(" returning to frame at ");
       if (tmp_address.SetLoadAddress(m_return_addr, &GetTarget())) {
@@ -217,8 +214,8 @@
 }
 
 bool ThreadPlanStepOut::DoPlanExplainsStop(Event *event_ptr) {
-  // If the step out plan is done, then we just need to step through the inlined
-  // frame.
+  // If the step out plan is done, then we just need to step through the
+  // inlined frame.
   if (m_step_out_to_inline_plan_sp) {
     return m_step_out_to_inline_plan_sp->MischiefManaged();
   } else if (m_step_through_inline_plan_sp) {
@@ -232,16 +229,15 @@
     return m_step_out_further_plan_sp->MischiefManaged();
   }
 
-  // We don't explain signals or breakpoints (breakpoints that handle stepping
-  // in or
-  // out will be handled by a child plan.
+  // We don't explain signals or breakpoints (breakpoints that handle
+  // stepping in or out will be handled by a child plan.
 
   StopInfoSP stop_info_sp = GetPrivateStopInfo();
   if (stop_info_sp) {
     StopReason reason = stop_info_sp->GetStopReason();
     if (reason == eStopReasonBreakpoint) {
-      // If this is OUR breakpoint, we're fine, otherwise we don't know why this
-      // happened...
+      // If this is OUR breakpoint, we're fine, otherwise we don't know
+      // why this happened...
       BreakpointSiteSP site_sp(
           m_thread.GetProcess()->GetBreakpointSiteList().FindByID(
               stop_info_sp->GetValue()));
@@ -253,8 +249,8 @@
         if (m_step_out_to_id == frame_zero_id)
           done = true;
         else if (m_step_out_to_id < frame_zero_id) {
-          // Either we stepped past the breakpoint, or the stack ID calculation
-          // was incorrect and we should probably stop.
+          // Either we stepped past the breakpoint, or the stack ID
+          // calculation was incorrect and we should probably stop.
           done = true;
         } else {
           done = (m_immediate_step_from_id < frame_zero_id);
@@ -267,12 +263,11 @@
           }
         }
 
-        // If there was only one owner, then we're done.  But if we also hit
-        // some
-        // user breakpoint on our way out, we should mark ourselves as done, but
-        // also not claim to explain the stop, since it is more important to
-        // report
-        // the user breakpoint than the step out completion.
+        // If there was only one owner, then we're done.  But if we also
+        // hit some user breakpoint on our way out, we should mark
+        // ourselves as done, but also not claim to explain the stop,
+        // since it is more important to report the user breakpoint than
+        // the step out completion.
 
         if (site_sp->GetNumberOfOwners() == 1)
           return true;
@@ -295,7 +290,8 @@
     if (m_step_out_to_inline_plan_sp->MischiefManaged()) {
       // Now step through the inlined stack we are in:
       if (QueueInlinedStepPlan(true)) {
-        // If we can't queue a plan to do this, then just call ourselves done.
+        // If we can't queue a plan to do this, then just call ourselves
+        // done.
         m_step_out_to_inline_plan_sp.reset();
         SetPlanComplete(false);
         return true;
@@ -320,9 +316,8 @@
     done = !(frame_zero_id < m_step_out_to_id);
   }
 
-  // The normal step out computations think we are done, so all we need to do is
-  // consult the ShouldStopHere,
-  // and we are done.
+  // The normal step out computations think we are done, so all we need to
+  // do is consult the ShouldStopHere, and we are done.
 
   if (done) {
     if (InvokeShouldStopHereCallback(eFrameCompareOlder)) {
@@ -374,11 +369,9 @@
   if (IsPlanComplete()) {
     // Did I reach my breakpoint?  If so I'm done.
     //
-    // I also check the stack depth, since if we've blown past the breakpoint
-    // for some
-    // reason and we're now stopping for some other reason altogether, then
-    // we're done
-    // with this step out operation.
+    // I also check the stack depth, since if we've blown past the
+    // breakpoint for some reason and we're now stopping for some other
+    // reason altogether, then we're done with this step out operation.
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
     if (log)
@@ -396,11 +389,9 @@
 }
 
 bool ThreadPlanStepOut::QueueInlinedStepPlan(bool queue_now) {
-  // Now figure out the range of this inlined block, and set up a "step through
-  // range"
-  // plan for that.  If we've been provided with a context, then use the block
-  // in that
-  // context.
+  // Now figure out the range of this inlined block, and set up a "step
+  // through range" plan for that.  If we've been provided with a context,
+  // then use the block in that context.
   StackFrameSP immediate_return_from_sp(m_thread.GetStackFrameAtIndex(0));
   if (!immediate_return_from_sp)
     return false;
@@ -477,8 +468,8 @@
 }
 
 bool ThreadPlanStepOut::IsPlanStale() {
-  // If we are still lower on the stack than the frame we are returning to, then
-  // there's something for us to do.  Otherwise, we're stale.
+  // If we are still lower on the stack than the frame we are returning
+  // to, then there's something for us to do.  Otherwise, we're stale.
 
   StackID frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
   return !(frame_zero_id < m_step_out_to_id);
Index: source/Target/ThreadPlanStepOverBreakpoint.cpp
===================================================================
--- source/Target/ThreadPlanStepOverBreakpoint.cpp
+++ source/Target/ThreadPlanStepOverBreakpoint.cpp
@@ -22,8 +22,8 @@
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
-// ThreadPlanStepOverBreakpoint: Single steps over a breakpoint bp_site_sp at
-// the pc.
+// ThreadPlanStepOverBreakpoint: Single steps over a breakpoint bp_site_sp
+// at the pc.
 //----------------------------------------------------------------------
 
 ThreadPlanStepOverBreakpoint::ThreadPlanStepOverBreakpoint(Thread &thread)
@@ -57,16 +57,14 @@
   StopInfoSP stop_info_sp = GetPrivateStopInfo();
   if (stop_info_sp) {
     // It's a little surprising that we stop here for a breakpoint hit.
-    // However, when you single step ONTO a breakpoint
-    // we still want to call that a breakpoint hit, and trigger the actions,
-    // etc.  Otherwise you would see the
-    // PC at the breakpoint without having triggered the actions, then you'd
-    // continue, the PC wouldn't change,
-    // and you'd see the breakpoint hit, which would be odd.
-    // So the lower levels fake "step onto breakpoint address" and return that
-    // as a breakpoint.  So our trace
-    // step COULD appear as a breakpoint hit if the next instruction also
-    // contained a breakpoint.
+    // However, when you single step ONTO a breakpoint we still want to
+    // call that a breakpoint hit, and trigger the actions, etc.
+    // Otherwise you would see the PC at the breakpoint without having
+    // triggered the actions, then you'd continue, the PC wouldn't change,
+    // and you'd see the breakpoint hit, which would be odd. So the lower
+    // levels fake "step onto breakpoint address" and return that as a
+    // breakpoint.  So our trace step COULD appear as a breakpoint hit if
+    // the next instruction also contained a breakpoint.
     StopReason reason = stop_info_sp->GetStopReason();
 
     switch (reason) {
@@ -75,20 +73,18 @@
       return true;
     case eStopReasonBreakpoint:
       // It's a little surprising that we stop here for a breakpoint hit.
-      // However, when you single step ONTO a
-      // breakpoint we still want to call that a breakpoint hit, and trigger the
-      // actions, etc.  Otherwise you
-      // would see the PC at the breakpoint without having triggered the
-      // actions, then you'd continue, the PC
-      // wouldn't change, and you'd see the breakpoint hit, which would be odd.
-      // So the lower levels fake "step onto breakpoint address" and return that
-      // as a breakpoint hit.  So our trace
-      // step COULD appear as a breakpoint hit if the next instruction also
-      // contained a breakpoint.  We don't want
-      // to handle that, since we really don't know what to do with breakpoint
-      // hits.  But make sure we don't set
-      // ourselves to auto-continue or we'll wrench control away from the plans
-      // that can deal with this.
+      // However, when you single step ONTO a breakpoint we still want to
+      // call that a breakpoint hit, and trigger the actions, etc.
+      // Otherwise you would see the PC at the breakpoint without having
+      // triggered the actions, then you'd continue, the PC wouldn't
+      // change, and you'd see the breakpoint hit, which would be odd. So
+      // the lower levels fake "step onto breakpoint address" and return
+      // that as a breakpoint hit.  So our trace step COULD appear as a
+      // breakpoint hit if the next instruction also contained a
+      // breakpoint.  We don't want to handle that, since we really don't
+      // know what to do with breakpoint hits.  But make sure we don't set
+      // ourselves to auto-continue or we'll wrench control away from the
+      // plans that can deal with this.
       SetAutoContinue(false);
       return false;
     default:
@@ -129,16 +125,15 @@
   lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC();
 
   if (pc_addr == m_breakpoint_addr) {
-    // If we are still at the PC of our breakpoint, then for some reason we
-    // didn't
-    // get a chance to run.
+    // If we are still at the PC of our breakpoint, then for some reason
+    // we didn't get a chance to run.
     return false;
   } else {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
     if (log)
       log->Printf("Completed step over breakpoint plan.");
-    // Otherwise, re-enable the breakpoint we were stepping over, and we're
-    // done.
+    // Otherwise, re-enable the breakpoint we were stepping over, and
+    // we're done.
     ReenableBreakpointSite();
     ThreadPlan::MischiefManaged();
     return true;
Index: source/Target/ThreadPlanStepOverRange.cpp
===================================================================
--- source/Target/ThreadPlanStepOverRange.cpp
+++ source/Target/ThreadPlanStepOverRange.cpp
@@ -31,9 +31,8 @@
 uint32_t ThreadPlanStepOverRange::s_default_flag_values = 0;
 
 //----------------------------------------------------------------------
-// ThreadPlanStepOverRange: Step through a stack range, either stepping over or
-// into
-// based on the value of \a type.
+// ThreadPlanStepOverRange: Step through a stack range, either stepping
+// over or into based on the value of \a type.
 //----------------------------------------------------------------------
 
 ThreadPlanStepOverRange::ThreadPlanStepOverRange(
@@ -90,38 +89,35 @@
     GetFlags().Set(ThreadPlanShouldStopHere::eStepOutAvoidNoDebug);
   else
     GetFlags().Clear(ThreadPlanShouldStopHere::eStepOutAvoidNoDebug);
-  // Step Over plans should always avoid no-debug on step in.  Seems like you
-  // shouldn't
-  // have to say this, but a tail call looks more like a step in that a step
-  // out, so
-  // we want to catch this case.
+  // Step Over plans should always avoid no-debug on step in.  Seems like
+  // you shouldn't have to say this, but a tail call looks more like a
+  // step in that a step out, so we want to catch this case.
   GetFlags().Set(ThreadPlanShouldStopHere::eStepInAvoidNoDebug);
 }
 
 bool ThreadPlanStepOverRange::IsEquivalentContext(
     const SymbolContext &context) {
-  // Match as much as is specified in the m_addr_context:
-  // This is a fairly loose sanity check.  Note, sometimes the target doesn't
-  // get filled
-  // in so I left out the target check.  And sometimes the module comes in as
-  // the .o file from the
-  // inlined range, so I left that out too...
+  // Match as much as is specified in the m_addr_context: This is a fairly
+  // loose sanity check.  Note, sometimes the target doesn't get filled in
+  // so I left out the target check.  And sometimes the module comes in as
+  // the .o file from the inlined range, so I left that out too...
   if (m_addr_context.comp_unit) {
     if (m_addr_context.comp_unit != context.comp_unit)
       return false;
     if (m_addr_context.function) {
       if (m_addr_context.function != context.function)
         return false;
-      // It is okay to return to a different block of a straight function, we
-      // only have to
-      // be more careful if returning from one inlined block to another.
+      // It is okay to return to a different block of a straight function,
+      // we only have to be more careful if returning from one inlined
+      // block to another.
       if (m_addr_context.block->GetInlinedFunctionInfo() == nullptr &&
           context.block->GetInlinedFunctionInfo() == nullptr)
         return true;
       return m_addr_context.block == context.block;
     }
   }
-  // Fall back to symbol if we have no decision from comp_unit/function/block.
+  // Fall back to symbol if we have no decision from
+  // comp_unit/function/block.
   if (m_addr_context.symbol && m_addr_context.symbol == context.symbol) {
     return true;
   }
@@ -139,9 +135,9 @@
     log->Printf("ThreadPlanStepOverRange reached %s.", s.GetData());
   }
 
-  // If we're out of the range but in the same frame or in our caller's frame
-  // then we should stop.
-  // When stepping out we only stop others if we are forcing running one thread.
+  // If we're out of the range but in the same frame or in our caller's
+  // frame then we should stop. When stepping out we only stop others if
+  // we are forcing running one thread.
   bool stop_others = (m_stop_others == lldb::eOnlyThisThread);
   ThreadPlanSP new_plan_sp;
   FrameComparison frame_order = CompareCurrentFrameToStartFrame();
@@ -149,14 +145,12 @@
   if (frame_order == eFrameCompareOlder) {
     // If we're in an older frame then we should stop.
     //
-    // A caveat to this is if we think the frame is older but we're actually in
-    // a trampoline.
-    // I'm going to make the assumption that you wouldn't RETURN to a
-    // trampoline.  So if we are
-    // in a trampoline we think the frame is older because the trampoline
-    // confused the backtracer.
-    // As below, we step through first, and then try to figure out how to get
-    // back out again.
+    // A caveat to this is if we think the frame is older but we're
+    // actually in a trampoline. I'm going to make the assumption that you
+    // wouldn't RETURN to a trampoline.  So if we are in a trampoline we
+    // think the frame is older because the trampoline confused the
+    // backtracer. As below, we step through first, and then try to figure
+    // out how to get back out again.
 
     new_plan_sp =
         m_thread.QueueThreadPlanForStepThrough(m_stack_id, false, stop_others);
@@ -165,9 +159,8 @@
       log->Printf(
           "Thought I stepped out, but in fact arrived at a trampoline.");
   } else if (frame_order == eFrameCompareYounger) {
-    // Make sure we really are in a new frame.  Do that by unwinding and seeing
-    // if the
-    // start function really is our start function...
+    // Make sure we really are in a new frame.  Do that by unwinding and
+    // seeing if the start function really is our start function...
     for (uint32_t i = 1;; ++i) {
       StackFrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(i);
       if (!older_frame_sp) {
@@ -200,28 +193,24 @@
 
     if (!InSymbol()) {
       // This one is a little tricky.  Sometimes we may be in a stub or
-      // something similar,
-      // in which case we need to get out of there.  But if we are in a stub
-      // then it's
-      // likely going to be hard to get out from here.  It is probably easiest
-      // to step into the
-      // stub, and then it will be straight-forward to step out.
+      // something similar, in which case we need to get out of there.
+      // But if we are in a stub then it's likely going to be hard to get
+      // out from here.  It is probably easiest to step into the stub, and
+      // then it will be straight-forward to step out.
       new_plan_sp = m_thread.QueueThreadPlanForStepThrough(m_stack_id, false,
                                                            stop_others);
     } else {
-      // The current clang (at least through 424) doesn't always get the address
-      // range for the
-      // DW_TAG_inlined_subroutines right, so that when you leave the inlined
-      // range the line table says
-      // you are still in the source file of the inlining function.  This is
-      // bad, because now you are missing
-      // the stack frame for the function containing the inlining, and if you
-      // sensibly do "finish" to get
-      // out of this function you will instead exit the containing function.
-      // To work around this, we check whether we are still in the source file
-      // we started in, and if not assume
-      // it is an error, and push a plan to get us out of this line and back to
-      // the containing file.
+      // The current clang (at least through 424) doesn't always get the
+      // address range for the DW_TAG_inlined_subroutines right, so that
+      // when you leave the inlined range the line table says you are
+      // still in the source file of the inlining function.  This is bad,
+      // because now you are missing the stack frame for the function
+      // containing the inlining, and if you sensibly do "finish" to get
+      // out of this function you will instead exit the containing
+      // function. To work around this, we check whether we are still in
+      // the source file we started in, and if not assume it is an error,
+      // and push a plan to get us out of this line and back to the
+      // containing file.
 
       if (m_addr_context.line_entry.IsValid()) {
         SymbolContext sc;
@@ -232,7 +221,8 @@
                   m_addr_context.line_entry.original_file &&
               sc.comp_unit == m_addr_context.comp_unit &&
               sc.function == m_addr_context.function) {
-            // Okay, find the next occurrence of this file in the line table:
+            // Okay, find the next occurrence of this file in the line
+            // table:
             LineTable *line_table = m_addr_context.comp_unit->GetLineTable();
             if (line_table) {
               Address cur_address = frame_sp->GetFrameCodeAddress();
@@ -243,15 +233,12 @@
                 LineEntry next_line_entry;
                 bool step_past_remaining_inline = false;
                 if (entry_idx > 0) {
-                  // We require the previous line entry and the current line
-                  // entry come
-                  // from the same file.
-                  // The other requirement is that the previous line table entry
-                  // be part of an
-                  // inlined block, we don't want to step past cases where
-                  // people have inlined
-                  // some code fragment by using #include <source-fragment.c>
-                  // directly.
+                  // We require the previous line entry and the current
+                  // line entry come from the same file. The other
+                  // requirement is that the previous line table entry be
+                  // part of an inlined block, we don't want to step past
+                  // cases where people have inlined some code fragment by
+                  // using #include <source-fragment.c> directly.
                   LineEntry prev_line_entry;
                   if (line_table->GetLineEntryAtIndex(entry_idx - 1,
                                                       prev_line_entry) &&
@@ -281,8 +268,8 @@
                   uint32_t look_ahead_step = 1;
                   while (line_table->GetLineEntryAtIndex(
                       entry_idx + look_ahead_step, next_line_entry)) {
-                    // Make sure we haven't wandered out of the function we
-                    // started from...
+                    // Make sure we haven't wandered out of the function
+                    // we started from...
                     Address next_line_address =
                         next_line_entry.range.GetBaseAddress();
                     Function *next_line_function =
@@ -318,12 +305,12 @@
     }
   }
 
-  // If we get to this point, we're not going to use a previously set "next
-  // branch" breakpoint, so delete it:
+  // If we get to this point, we're not going to use a previously set
+  // "next branch" breakpoint, so delete it:
   ClearNextBranchBreakpoint();
 
-  // If we haven't figured out something to do yet, then ask the ShouldStopHere
-  // callback:
+  // If we haven't figured out something to do yet, then ask the
+  // ShouldStopHere callback:
   if (!new_plan_sp) {
     new_plan_sp = CheckShouldStopHereAndQueueStepOut(frame_order);
   }
@@ -337,9 +324,8 @@
   }
 
   if (!new_plan_sp) {
-    // For efficiencies sake, we know we're done here so we don't have to do
-    // this
-    // calculation again in MischiefManaged.
+    // For efficiencies sake, we know we're done here so we don't have to
+    // do this calculation again in MischiefManaged.
     SetPlanComplete();
     return true;
   } else
@@ -347,16 +333,12 @@
 }
 
 bool ThreadPlanStepOverRange::DoPlanExplainsStop(Event *event_ptr) {
-  // For crashes, breakpoint hits, signals, etc, let the base plan (or some plan
-  // above us)
-  // handle the stop.  That way the user can see the stop, step around, and then
-  // when they
-  // are done, continue and have their step complete.  The exception is if we've
-  // hit our
-  // "run to next branch" breakpoint.
-  // Note, unlike the step in range plan, we don't mark ourselves complete if we
-  // hit an
-  // unexplained breakpoint/crash.
+  // For crashes, breakpoint hits, signals, etc, let the base plan (or
+  // some plan above us) handle the stop.  That way the user can see the
+  // stop, step around, and then when they are done, continue and have
+  // their step complete.  The exception is if we've hit our "run to next
+  // branch" breakpoint. Note, unlike the step in range plan, we don't
+  // mark ourselves complete if we hit an unexplained breakpoint/crash.
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
   StopInfoSP stop_info_sp = GetPrivateStopInfo();
@@ -386,9 +368,9 @@
   if (resume_state != eStateSuspended && m_first_resume) {
     m_first_resume = false;
     if (resume_state == eStateStepping && current_plan) {
-      // See if we are about to step over an inlined call in the middle of the
-      // inlined stack, if so figure
-      // out its extents and reset our range to step over that.
+      // See if we are about to step over an inlined call in the middle of
+      // the inlined stack, if so figure out its extents and reset our
+      // range to step over that.
       bool in_inlined_stack = m_thread.DecrementCurrentInlinedDepth();
       if (in_inlined_stack) {
         Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
Index: source/Target/ThreadPlanStepRange.cpp
===================================================================
--- source/Target/ThreadPlanStepRange.cpp
+++ source/Target/ThreadPlanStepRange.cpp
@@ -31,8 +31,8 @@
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
-// ThreadPlanStepRange: Step through a stack range, either stepping over or into
-// based on the value of \a type.
+// ThreadPlanStepRange: Step through a stack range, either stepping over
+// or into based on the value of \a type.
 //----------------------------------------------------------------------
 
 ThreadPlanStepRange::ThreadPlanStepRange(ThreadPlanKind kind, const char *name,
@@ -75,14 +75,13 @@
 
 void ThreadPlanStepRange::AddRange(const AddressRange &new_range) {
   // For now I'm just adding the ranges.  At some point we may want to
-  // condense the ranges if they overlap, though I don't think it is likely
-  // to be very important.
+  // condense the ranges if they overlap, though I don't think it is
+  // likely to be very important.
   m_address_ranges.push_back(new_range);
 
-  // Fill the slot for this address range with an empty DisassemblerSP in the
-  // instruction ranges. I want the
-  // indices to match, but I don't want to do the work to disassemble this range
-  // if I don't step into it.
+  // Fill the slot for this address range with an empty DisassemblerSP in
+  // the instruction ranges. I want the indices to match, but I don't want
+  // to do the work to disassemble this range if I don't step into it.
   m_instruction_ranges.push_back(DisassemblerSP());
 }
 
@@ -115,7 +114,8 @@
   }
 
   if (!ret_value && !m_given_ranges_only) {
-    // See if we've just stepped to another part of the same line number...
+    // See if we've just stepped to another part of the same line
+    // number...
     StackFrame *frame = m_thread.GetStackFrameAtIndex(0).get();
 
     SymbolContext new_context(
@@ -157,13 +157,12 @@
           }
         } else if (new_context.line_entry.range.GetBaseAddress().GetLoadAddress(
                        m_thread.CalculateTarget().get()) != pc_load_addr) {
-          // Another thing that sometimes happens here is that we step out of
-          // one line into the MIDDLE of another
-          // line.  So far I mostly see this due to bugs in the debug
-          // information.
-          // But we probably don't want to be in the middle of a line range, so
-          // in that case reset the stepping
-          // range to the line we've stepped into the middle of and continue.
+          // Another thing that sometimes happens here is that we step out
+          // of one line into the MIDDLE of another line.  So far I mostly
+          // see this due to bugs in the debug information. But we
+          // probably don't want to be in the middle of a line range, so
+          // in that case reset the stepping range to the line we've
+          // stepped into the middle of and continue.
           m_addr_context = new_context;
           m_address_ranges.clear();
           AddRange(m_addr_context.line_entry.range);
@@ -202,12 +201,11 @@
   return false;
 }
 
-// FIXME: This should also handle inlining if we aren't going to do inlining in
-// the
-// main stack.
+// FIXME: This should also handle inlining if we aren't going to do
+// inlining in the main stack.
 //
-// Ideally we should remember the whole stack frame list, and then compare that
-// to the current list.
+// Ideally we should remember the whole stack frame list, and then compare
+// that to the current list.
 
 lldb::FrameComparison ThreadPlanStepRange::CompareCurrentFrameToStartFrame() {
   FrameComparison frame_order;
@@ -259,10 +257,9 @@
       if (!m_instruction_ranges[i])
         return nullptr;
       else {
-        // Find where we are in the instruction list as well.  If we aren't at
-        // an instruction,
-        // return nullptr. In this case, we're probably lost, and shouldn't try
-        // to do anything fancy.
+        // Find where we are in the instruction list as well.  If we
+        // aren't at an instruction, return nullptr. In this case, we're
+        // probably lost, and shouldn't try to do anything fancy.
 
         insn_offset =
             m_instruction_ranges[i]
@@ -296,15 +293,14 @@
     return true;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
-  // Stepping through ranges using breakpoints doesn't work yet, but with this
-  // off we fall back to instruction
-  // single stepping.
+  // Stepping through ranges using breakpoints doesn't work yet, but with
+  // this off we fall back to instruction single stepping.
   if (!m_use_fast_step)
     return false;
 
   lldb::addr_t cur_addr = GetThread().GetRegisterContext()->GetPC();
-  // Find the current address in our address ranges, and fetch the disassembly
-  // if we haven't already:
+  // Find the current address in our address ranges, and fetch the
+  // disassembly if we haven't already:
   size_t pc_index;
   size_t range_index;
   InstructionList *instructions =
@@ -382,11 +378,10 @@
     // If we've hit the next branch breakpoint, then clear it.
     size_t num_owners = bp_site_sp->GetNumberOfOwners();
     bool explains_stop = true;
-    // If all the owners are internal, then we are probably just stepping over
-    // this range from multiple threads,
-    // or multiple frames, so we want to continue.  If one is not internal, then
-    // we should not explain the stop,
-    // and let the user breakpoint handle the stop.
+    // If all the owners are internal, then we are probably just stepping
+    // over this range from multiple threads, or multiple frames, so we
+    // want to continue.  If one is not internal, then we should not
+    // explain the stop, and let the user breakpoint handle the stop.
     for (size_t i = 0; i < num_owners; i++) {
       if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
         explains_stop = false;
@@ -413,13 +408,11 @@
 }
 
 bool ThreadPlanStepRange::MischiefManaged() {
-  // If we have pushed some plans between ShouldStop & MischiefManaged, then
-  // we're not done...
-  // I do this check first because we might have stepped somewhere that will
-  // fool InRange into
-  // thinking it needs to step past the end of that line.  This happens, for
-  // instance, when stepping
-  // over inlined code that is in the middle of the current line.
+  // If we have pushed some plans between ShouldStop & MischiefManaged,
+  // then we're not done... I do this check first because we might have
+  // stepped somewhere that will fool InRange into thinking it needs to
+  // step past the end of that line.  This happens, for instance, when
+  // stepping over inlined code that is in the middle of the current line.
 
   if (!m_no_more_plans)
     return false;
@@ -457,11 +450,12 @@
     }
     return true;
   } else if (frame_order == eFrameCompareEqual && InSymbol()) {
-    // If we are not in a place we should step through, we've gotten stale.
-    // One tricky bit here is that some stubs don't push a frame, so we should.
-    // check that we are in the same symbol.
+    // If we are not in a place we should step through, we've gotten
+    // stale. One tricky bit here is that some stubs don't push a frame,
+    // so we should. check that we are in the same symbol.
     if (!InRange()) {
-      // Set plan Complete when we reach next instruction just after the range
+      // Set plan Complete when we reach next instruction just after the
+      // range
       lldb::addr_t addr = m_thread.GetRegisterContext()->GetPC() - 1;
       size_t num_ranges = m_address_ranges.size();
       for (size_t i = 0; i < num_ranges; i++) {
Index: source/Target/ThreadPlanStepThrough.cpp
===================================================================
--- source/Target/ThreadPlanStepThrough.cpp
+++ source/Target/ThreadPlanStepThrough.cpp
@@ -26,10 +26,8 @@
 
 //----------------------------------------------------------------------
 // ThreadPlanStepThrough: If the current instruction is a trampoline, step
-// through it
-// If it is the beginning of the prologue of a function, step through that as
-// well.
-// FIXME: At present only handles DYLD trampolines.
+// through it If it is the beginning of the prologue of a function, step
+// through that as well. FIXME: At present only handles DYLD trampolines.
 //----------------------------------------------------------------------
 
 ThreadPlanStepThrough::ThreadPlanStepThrough(Thread &thread,
@@ -48,10 +46,10 @@
   if (m_sub_plan_sp) {
     m_start_address = GetThread().GetRegisterContext()->GetPC(0);
 
-    // We are going to return back to the concrete frame 1, we might pass by
-    // some inlined code that we're in
-    // the middle of by doing this, but it's easier than trying to figure out
-    // where the inlined code might return to.
+    // We are going to return back to the concrete frame 1, we might pass
+    // by some inlined code that we're in the middle of by doing this, but
+    // it's easier than trying to figure out where the inlined code might
+    // return to.
 
     StackFrameSP return_frame_sp = m_thread.GetFrameWithStackID(m_stack_id);
 
@@ -135,11 +133,9 @@
 }
 
 bool ThreadPlanStepThrough::DoPlanExplainsStop(Event *event_ptr) {
-  // If we have a sub-plan, it will have been asked first if we explain the
-  // stop, and
-  // we won't get asked.  The only time we would be the one directly asked this
-  // question
-  // is if we hit our backstop breakpoint.
+  // If we have a sub-plan, it will have been asked first if we explain
+  // the stop, and we won't get asked.  The only time we would be the one
+  // directly asked this question is if we hit our backstop breakpoint.
 
   return HitOurBackstopBreakpoint();
 }
@@ -155,25 +151,23 @@
     return true;
   }
 
-  // If we don't have a sub-plan, then we're also done (can't see how we would
-  // ever get here
-  // without a plan, but just in case.
+  // If we don't have a sub-plan, then we're also done (can't see how we
+  // would ever get here without a plan, but just in case.
 
   if (!m_sub_plan_sp) {
     SetPlanComplete();
     return true;
   }
 
-  // If the current sub plan is not done, we don't want to stop.  Actually, we
-  // probably won't
-  // ever get here in this state, since we generally won't get asked any
-  // questions if out
-  // current sub-plan is not done...
+  // If the current sub plan is not done, we don't want to stop.
+  // Actually, we probably won't ever get here in this state, since we
+  // generally won't get asked any questions if out current sub-plan is
+  // not done...
   if (!m_sub_plan_sp->IsPlanComplete())
     return false;
 
-  // If our current sub plan failed, then let's just run to our backstop.  If we
-  // can't do that then just stop.
+  // If our current sub plan failed, then let's just run to our backstop.
+  // If we can't do that then just stop.
   if (!m_sub_plan_sp->PlanSucceeded()) {
     if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID) {
       m_sub_plan_sp.reset();
@@ -184,10 +178,9 @@
     }
   }
 
-  // Next see if there is a specific step through plan at our current pc (these
-  // might
-  // chain, for instance stepping through a dylib trampoline to the objc
-  // dispatch function...)
+  // Next see if there is a specific step through plan at our current pc
+  // (these might chain, for instance stepping through a dylib trampoline
+  // to the objc dispatch function...)
   LookForPlanToStepThroughFromCurrentPC();
   if (m_sub_plan_sp) {
     PushPlan(m_sub_plan_sp);
Index: source/Target/ThreadPlanStepUntil.cpp
===================================================================
--- source/Target/ThreadPlanStepUntil.cpp
+++ source/Target/ThreadPlanStepUntil.cpp
@@ -25,8 +25,8 @@
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
-// ThreadPlanStepUntil: Run until we reach a given line number or step out of
-// the current frame
+// ThreadPlanStepUntil: Run until we reach a given line number or step out
+// of the current frame
 //----------------------------------------------------------------------
 
 ThreadPlanStepUntil::ThreadPlanStepUntil(Thread &thread,
@@ -48,8 +48,8 @@
     m_step_from_insn = frame_sp->GetStackID().GetPC();
     lldb::user_id_t thread_id = m_thread.GetID();
 
-    // Find the return address and set a breakpoint there:
-    // FIXME - can we do this more securely if we know first_insn?
+    // Find the return address and set a breakpoint there: FIXME - can we
+    // do this more securely if we know first_insn?
 
     StackFrameSP return_frame_sp(m_thread.GetStackFrameAtIndex(frame_idx + 1));
     if (return_frame_sp) {
@@ -151,8 +151,8 @@
     StopReason reason = stop_info_sp->GetStopReason();
 
     if (reason == eStopReasonBreakpoint) {
-      // If this is OUR breakpoint, we're fine, otherwise we don't know why this
-      // happened...
+      // If this is OUR breakpoint, we're fine, otherwise we don't know
+      // why this happened...
       BreakpointSiteSP this_site =
           m_thread.GetProcess()->GetBreakpointSiteList().FindByID(
               stop_info_sp->GetValue());
@@ -163,18 +163,13 @@
 
       if (this_site->IsBreakpointAtThisSite(m_return_bp_id)) {
         // If we are at our "step out" breakpoint, and the stack depth has
-        // shrunk, then
-        // this is indeed our stop.
-        // If the stack depth has grown, then we've hit our step out breakpoint
-        // recursively.
-        // If we are the only breakpoint at that location, then we do explain
-        // the stop, and
-        // we'll just continue.
-        // If there was another breakpoint here, then we don't explain the stop,
-        // but we won't
+        // shrunk, then this is indeed our stop. If the stack depth has
+        // grown, then we've hit our step out breakpoint recursively. If
+        // we are the only breakpoint at that location, then we do explain
+        // the stop, and we'll just continue. If there was another
+        // breakpoint here, then we don't explain the stop, but we won't
         // mark ourselves Completed, because maybe that breakpoint will
-        // continue, and then
-        // we'll finish the "until".
+        // continue, and then we'll finish the "until".
         bool done;
         StackID cur_frame_zero_id;
 
@@ -209,8 +204,8 @@
             else {
               StackFrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(1);
 
-              // But if we can't even unwind one frame we should just get out of
-              // here & stop...
+              // But if we can't even unwind one frame we should just get
+              // out of here & stop...
               if (older_frame_sp) {
                 const SymbolContext &older_context =
                     older_frame_sp->GetSymbolContext(eSymbolContextEverything);
@@ -228,10 +223,10 @@
             else
               m_should_stop = false;
 
-            // Otherwise we've hit this breakpoint recursively.  If we're the
-            // only breakpoint here, then we do explain the stop, and we'll
-            // continue.
-            // If not then we should let higher plans handle this stop.
+            // Otherwise we've hit this breakpoint recursively.  If we're
+            // the only breakpoint here, then we do explain the stop, and
+            // we'll continue. If not then we should let higher plans
+            // handle this stop.
             if (this_site->GetNumberOfOwners() == 1)
               m_explains_stop = true;
             else {
@@ -242,8 +237,8 @@
           }
         }
       }
-      // If we get here we haven't hit any of our breakpoints, so let the higher
-      // plans take care of the stop.
+      // If we get here we haven't hit any of our breakpoints, so let the
+      // higher plans take care of the stop.
       m_explains_stop = false;
       return;
     } else if (IsUsuallyUnexplainedStopReason(reason)) {
@@ -255,17 +250,16 @@
 }
 
 bool ThreadPlanStepUntil::DoPlanExplainsStop(Event *event_ptr) {
-  // We don't explain signals or breakpoints (breakpoints that handle stepping
-  // in or
-  // out will be handled by a child plan.
+  // We don't explain signals or breakpoints (breakpoints that handle
+  // stepping in or out will be handled by a child plan.
   AnalyzeStop();
   return m_explains_stop;
 }
 
 bool ThreadPlanStepUntil::ShouldStop(Event *event_ptr) {
   // If we've told our self in ExplainsStop that we plan to continue, then
-  // do so here.  Otherwise, as long as this thread has stopped for a reason,
-  // we will stop.
+  // do so here.  Otherwise, as long as this thread has stopped for a
+  // reason, we will stop.
 
   StopInfoSP stop_info_sp = GetPrivateStopInfo();
   if (!stop_info_sp || stop_info_sp->GetStopReason() == eStopReasonNone)
@@ -323,8 +317,8 @@
 }
 
 bool ThreadPlanStepUntil::MischiefManaged() {
-  // I'm letting "PlanExplainsStop" do all the work, and just reporting that
-  // here.
+  // I'm letting "PlanExplainsStop" do all the work, and just reporting
+  // that here.
   bool done = false;
   if (IsPlanComplete()) {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
Index: source/Target/UnixSignals.cpp
===================================================================
--- source/Target/UnixSignals.cpp
+++ source/Target/UnixSignals.cpp
@@ -65,11 +65,10 @@
 UnixSignals::~UnixSignals() = default;
 
 void UnixSignals::Reset() {
-  // This builds one standard set of Unix Signals.  If yours aren't quite in
-  // this
-  // order, you can either subclass this class, and use Add & Remove to change
-  // them
-  // or you can subclass and build them afresh in your constructor;
+  // This builds one standard set of Unix Signals.  If yours aren't quite
+  // in this order, you can either subclass this class, and use Add &
+  // Remove to change them or you can subclass and build them afresh in
+  // your constructor;
   //
   // Note: the signals below are the Darwin signals.  Do not change these!
   m_signals.clear();
@@ -306,8 +305,8 @@
     bool signal_notify = false;
     GetSignalInfo(signo, signal_suppress, signal_stop, signal_notify);
 
-    // If any of filtering conditions are not met,
-    // we move on to the next signal.
+    // If any of filtering conditions are not met, we move on to the next
+    // signal.
     if (should_suppress.hasValue() &&
         signal_suppress != should_suppress.getValue())
       continue;
Index: source/Utility/ArchSpec.cpp
===================================================================
--- source/Utility/ArchSpec.cpp
+++ source/Utility/ArchSpec.cpp
@@ -41,7 +41,8 @@
 
 } // namespace lldb_private
 
-// This core information can be looked using the ArchSpec::Core as the index
+// This core information can be looked using the ArchSpec::Core as the
+// index
 static const CoreDefinition g_core_definitions[] = {
     {eByteOrderLittle, 4, 2, 4, llvm::Triple::arm, ArchSpec::eCore_arm_generic,
      "arm"},
@@ -222,9 +223,9 @@
     {eByteOrderLittle, 4, 1, 1, llvm::Triple::kalimba, ArchSpec::eCore_kalimba5,
      "kalimba5"}};
 
-// Ensure that we have an entry in the g_core_definitions for each core. If you
-// comment out an entry above,
-// you will need to comment out the corresponding ArchSpec::Core enumeration.
+// Ensure that we have an entry in the g_core_definitions for each core.
+// If you comment out an entry above, you will need to comment out the
+// corresponding ArchSpec::Core enumeration.
 static_assert(sizeof(g_core_definitions) / sizeof(CoreDefinition) ==
                   ArchSpec::kNumCores,
               "make sure we have one core definition for each core");
@@ -262,8 +263,8 @@
 //===----------------------------------------------------------------------===//
 // A table that gets searched linearly for matches. This table is used to
 // convert cpu type and subtypes to architecture names, and to convert
-// architecture names to cpu types and subtypes. The ordering is important and
-// allows the precedence to be set when the table is built.
+// architecture names to cpu types and subtypes. The ordering is important
+// and allows the precedence to be set when the table is built.
 #define SUBTYPE_MASK 0x00FFFFFFu
 
 static const ArchDefinitionEntry g_macho_arch_entries[] = {
@@ -381,8 +382,8 @@
      UINT32_MAX, SUBTYPE_MASK},
     {ArchSpec::eCore_x86_64_x86_64, llvm::MachO::CPU_TYPE_X86_64, CPU_ANY,
      UINT32_MAX, UINT32_MAX},
-    // Catch any unknown mach architectures so we can always use the object and
-    // symbol mach-o files
+    // Catch any unknown mach architectures so we can always use the
+    // object and symbol mach-o files
     {ArchSpec::eCore_uknownMach32, 0, 0, 0xFF000000u, 0x00000000u},
     {ArchSpec::eCore_uknownMach64, llvm::MachO::CPU_ARCH_ABI64, 0, 0xFF000000u,
      0x00000000u}};
@@ -394,8 +395,8 @@
 //===----------------------------------------------------------------------===//
 // A table that gets searched linearly for matches. This table is used to
 // convert cpu type and subtypes to architecture names, and to convert
-// architecture names to cpu types and subtypes. The ordering is important and
-// allows the precedence to be set when the table is built.
+// architecture names to cpu types and subtypes. The ordering is important
+// and allows the precedence to be set when the table is built.
 static const ArchDefinitionEntry g_elf_arch_entries[] = {
     {ArchSpec::eCore_sparc_generic, llvm::ELF::EM_SPARC, LLDB_INVALID_CPUTYPE,
      0xFFFFFFFFu, 0xFFFFFFFFu}, // Sparc
@@ -891,9 +892,9 @@
   if (GetTriple().getArch() == llvm::Triple::UnknownArch) {
     GetTriple().setArch(other.GetTriple().getArch());
 
-    // MachO unknown64 isn't really invalid as the debugger can
-    // still obtain information from the binary, e.g. line tables.
-    // As such, we don't update the core here.
+    // MachO unknown64 isn't really invalid as the debugger can still
+    // obtain information from the binary, e.g. line tables. As such, we
+    // don't update the core here.
     if (other.GetCore() != eCore_uknownMach64)
       UpdateCore();
   }
@@ -902,10 +903,9 @@
     if (other.TripleVendorWasSpecified())
       GetTriple().setEnvironment(other.GetTriple().getEnvironment());
   }
-  // If this and other are both arm ArchSpecs and this ArchSpec is a generic
-  // "some kind of arm"
-  // spec but the other ArchSpec is a specific arm core, adopt the specific arm
-  // core.
+  // If this and other are both arm ArchSpecs and this ArchSpec is a
+  // generic "some kind of arm" spec but the other ArchSpec is a specific
+  // arm core, adopt the specific arm core.
   if (GetTriple().getArch() == llvm::Triple::arm &&
       other.GetTriple().getArch() == llvm::Triple::arm &&
       IsCompatibleMatch(other) && GetCore() == ArchSpec::eCore_arm_generic &&
@@ -931,24 +931,21 @@
       if (core_def) {
         m_core = core_def->core;
         update_triple = false;
-        // Always use the architecture name because it might be more descriptive
-        // than the architecture enum ("armv7" -> llvm::Triple::arm).
+        // Always use the architecture name because it might be more
+        // descriptive than the architecture enum ("armv7" ->
+        // llvm::Triple::arm).
         m_triple.setArchName(llvm::StringRef(core_def->name));
         if (arch_type == eArchTypeMachO) {
           m_triple.setVendor(llvm::Triple::Apple);
 
-          // Don't set the OS.  It could be simulator, macosx, ios, watchos,
-          // tvos.  We could
-          // get close with the cpu type - but we can't get it right all of the
-          // time.  Better
-          // to leave this unset so other sections of code will set it when they
-          // have more
-          // information.
-          // NB: don't call m_triple.setOS (llvm::Triple::UnknownOS).  That sets
-          // the OSName to
-          // "unknown" and the ArchSpec::TripleVendorWasSpecified() method says
-          // that any
-          // OSName setting means it was specified.
+          // Don't set the OS.  It could be simulator, macosx, ios,
+          // watchos, tvos.  We could get close with the cpu type - but we
+          // can't get it right all of the time.  Better to leave this
+          // unset so other sections of code will set it when they have
+          // more information. NB: don't call m_triple.setOS
+          // (llvm::Triple::UnknownOS).  That sets the OSName to "unknown"
+          // and the ArchSpec::TripleVendorWasSpecified() method says that
+          // any OSName setting means it was specified.
         } else if (arch_type == eArchTypeELF) {
           switch (os) {
           case llvm::ELF::ELFOSABI_AIX:
@@ -977,7 +974,8 @@
           m_triple.setVendor(llvm::Triple::UnknownVendor);
           m_triple.setOS(llvm::Triple::UnknownOS);
         }
-        // Fall back onto setting the machine type if the arch by name failed...
+        // Fall back onto setting the machine type if the arch by name
+        // failed...
         if (m_triple.getArch() == llvm::Triple::UnknownArch)
           m_triple.setArch(core_def->machine);
       }
@@ -1019,11 +1017,10 @@
       rhs == llvm::Triple::UnknownEnvironment)
     return true;
 
-  // If one of the environment is Android and the other one is EABI then they
-  // are considered to
-  // be compatible. This is required as a workaround for shared libraries
-  // compiled for Android
-  // without the NOTE section indicating that they are using the Android ABI.
+  // If one of the environment is Android and the other one is EABI then
+  // they are considered to be compatible. This is required as a
+  // workaround for shared libraries compiled for Android without the NOTE
+  // section indicating that they are using the Android ABI.
   if ((lhs == llvm::Triple::Android && rhs == llvm::Triple::EABI) ||
       (rhs == llvm::Triple::Android && lhs == llvm::Triple::EABI) ||
       (lhs == llvm::Triple::GNUEABI && rhs == llvm::Triple::EABI) ||
@@ -1071,8 +1068,8 @@
     if (lhs_triple_os != rhs_triple_os) {
       const bool rhs_os_specified = rhs.TripleOSWasSpecified();
       const bool lhs_os_specified = TripleOSWasSpecified();
-      // Both architectures had the OS specified, so if they aren't
-      // equal then we return false
+      // Both architectures had the OS specified, so if they aren't equal
+      // then we return false
       if (rhs_os_specified && lhs_os_specified)
         return false;
 
@@ -1100,8 +1097,8 @@
   if (core_def) {
     m_core = core_def->core;
     // Set the byte order to the default byte order for an architecture.
-    // This can be modified if needed for cases when cores handle both
-    // big and little endian
+    // This can be modified if needed for cases when cores handle both big
+    // and little endian
     m_byte_order = core_def->default_byte_order;
   } else {
     Clear();
@@ -1198,9 +1195,8 @@
     break;
 
   // v. https://en.wikipedia.org/wiki/ARM_Cortex-M#Silicon_customization
-  // Cortex-M0 - ARMv6-M - armv6m
-  // Cortex-M3 - ARMv7-M - armv7m
-  // Cortex-M4 - ARMv7E-M - armv7em
+  // Cortex-M0 - ARMv6-M - armv6m Cortex-M3 - ARMv7-M - armv7m Cortex-M4 -
+  // ARMv7E-M - armv7em
   case ArchSpec::eCore_arm_armv7em:
     if (!enforce_exact_match) {
       if (core2 == ArchSpec::eCore_arm_generic)
@@ -1216,9 +1212,8 @@
     break;
 
   // v. https://en.wikipedia.org/wiki/ARM_Cortex-M#Silicon_customization
-  // Cortex-M0 - ARMv6-M - armv6m
-  // Cortex-M3 - ARMv7-M - armv7m
-  // Cortex-M4 - ARMv7E-M - armv7em
+  // Cortex-M0 - ARMv6-M - armv6m Cortex-M3 - ARMv7-M - armv7m Cortex-M4 -
+  // ARMv7E-M - armv7em
   case ArchSpec::eCore_arm_armv7m:
     if (!enforce_exact_match) {
       if (core2 == ArchSpec::eCore_arm_generic)
@@ -1464,10 +1459,10 @@
     // v. https://en.wikipedia.org/wiki/ARM_Cortex-M
     //
     // Cortex-M0 through Cortex-M7 are ARM processor cores which can only
-    // execute thumb instructions.  We map the cores to arch names like this:
+    // execute thumb instructions.  We map the cores to arch names like
+    // this:
     //
-    // Cortex-M0, Cortex-M0+, Cortex-M1:  armv6m
-    // Cortex-M3: armv7m
+    // Cortex-M0, Cortex-M0+, Cortex-M1:  armv6m Cortex-M3: armv7m
     // Cortex-M4, Cortex-M7: armv7em
 
     if (GetCore() == ArchSpec::Core::eCore_arm_armv7m ||
Index: source/Utility/Args.cpp
===================================================================
--- source/Utility/Args.cpp
+++ source/Utility/Args.cpp
@@ -19,12 +19,9 @@
 
 // A helper function for argument parsing.
 // Parses the initial part of the first argument using normal double quote
-// rules:
-// backslash escapes the double quote and itself. The parsed string is appended
-// to the second
-// argument. The function returns the unparsed portion of the string, starting
-// at the closing
-// quote.
+// rules: backslash escapes the double quote and itself. The parsed string
+// is appended to the second argument. The function returns the unparsed
+// portion of the string, starting at the closing quote.
 static llvm::StringRef ParseDoubleQuotes(llvm::StringRef quoted,
                                          std::string &result) {
   // Inside double quotes, '\' and '"' are special.
@@ -35,7 +32,8 @@
     result += quoted.substr(0, regular);
     quoted = quoted.substr(regular);
 
-    // If we have reached the end of string or the closing quote, we're done.
+    // If we have reached the end of string or the closing quote, we're
+    // done.
     if (quoted.empty() || quoted.front() == '"')
       break;
 
@@ -49,8 +47,7 @@
     }
 
     // If the character after the backslash is not a whitelisted escapable
-    // character, we
-    // leave the character sequence untouched.
+    // character, we leave the character sequence untouched.
     if (strchr(k_escapable_characters, quoted.front()) == nullptr)
       result += '\\';
 
@@ -70,24 +67,25 @@
   return count;
 }
 
-// A helper function for SetCommandString. Parses a single argument from the
-// command string, processing quotes and backslashes in a shell-like manner.
-// The function returns a tuple consisting of the parsed argument, the quote
-// char used, and the unparsed portion of the string starting at the first
-// unqouted, unescaped whitespace character.
+// A helper function for SetCommandString. Parses a single argument from
+// the command string, processing quotes and backslashes in a shell-like
+// manner. The function returns a tuple consisting of the parsed argument,
+// the quote char used, and the unparsed portion of the string starting at
+// the first unqouted, unescaped whitespace character.
 static std::tuple<std::string, char, llvm::StringRef>
 ParseSingleArgument(llvm::StringRef command) {
-  // Argument can be split into multiple discontiguous pieces, for example:
+  // Argument can be split into multiple discontiguous pieces, for
+  // example:
   //  "Hello ""World"
-  // this would result in a single argument "Hello World" (without the quotes)
-  // since the quotes would be removed and there is not space between the
-  // strings.
+  // this would result in a single argument "Hello World" (without the
+  // quotes) since the quotes would be removed and there is not space
+  // between the strings.
   std::string arg;
 
-  // Since we can have multiple quotes that form a single command
-  // in a command like: "Hello "world'!' (which will make a single
-  // argument "Hello world!") we remember the first quote character
-  // we encounter and use that for the quote character.
+  // Since we can have multiple quotes that form a single command in a
+  // command like: "Hello "world'!' (which will make a single argument
+  // "Hello world!") we remember the first quote character we encounter
+  // and use that for the quote character.
   char first_quote_char = '\0';
 
   bool arg_complete = false;
@@ -109,9 +107,8 @@
         break;
       }
 
-      // If the character after the backslash is not a whitelisted escapable
-      // character, we
-      // leave the character sequence untouched.
+      // If the character after the backslash is not a whitelisted
+      // escapable character, we leave the character sequence untouched.
       if (strchr(" \t\\'\"`", command.front()) == nullptr)
         arg += '\\';
 
@@ -138,8 +135,7 @@
         command = ParseDoubleQuotes(command, arg);
       else {
         // For single quotes, we simply skip ahead to the matching quote
-        // character
-        // (or the end of the string).
+        // character (or the end of the string).
         size_t quoted = command.find(special);
         arg += command.substr(0, quoted);
         command = command.substr(quoted);
@@ -272,11 +268,12 @@
 
 char **Args::GetArgumentVector() {
   assert(!m_argv.empty());
-  // TODO: functions like execve and posix_spawnp exhibit undefined behavior
-  // when argv or envp is null.  So the code below is actually wrong.  However,
-  // other code in LLDB depends on it being null.  The code has been acting this
-  // way for some time, so it makes sense to leave it this way until someone
-  // has the time to come along and fix it.
+  // TODO: functions like execve and posix_spawnp exhibit undefined
+  // behavior when argv or envp is null.  So the code below is actually
+  // wrong.  However, other code in LLDB depends on it being null.  The
+  // code has been acting this way for some time, so it makes sense to
+  // leave it this way until someone has the time to come along and fix
+  // it.
   return (m_argv.size() > 1) ? m_argv.data() : nullptr;
 }
 
@@ -555,17 +552,17 @@
         case '0':
           // 1 to 3 octal chars
           {
-            // Make a string that can hold onto the initial zero char,
-            // up to 3 octal digits, and a terminating NULL.
+            // Make a string that can hold onto the initial zero char, up
+            // to 3 octal digits, and a terminating NULL.
             char oct_str[5] = {'\0', '\0', '\0', '\0', '\0'};
 
             int i;
             for (i = 0; (p[i] >= '0' && p[i] <= '7') && i < 4; ++i)
               oct_str[i] = p[i];
 
-            // We don't want to consume the last octal character since
-            // the main for loop will do this for us, so we advance p by
-            // one less than i (even if i is zero)
+            // We don't want to consume the last octal character since the
+            // main for loop will do this for us, so we advance p by one
+            // less than i (even if i is zero)
             p += i - 1;
             unsigned long octal_value = ::strtoul(oct_str, nullptr, 8);
             if (octal_value <= UINT8_MAX) {
@@ -579,8 +576,8 @@
           if (isxdigit(p[1])) {
             ++p; // Skip the 'x'
 
-            // Make a string that can hold onto two hex chars plus a
-            // NULL terminator
+            // Make a string that can hold onto two hex chars plus a NULL
+            // terminator
             char hex_str[3] = {*p, '\0', '\0'};
             if (isxdigit(p[1])) {
               ++p; // Skip the first of the two hex chars
Index: source/Utility/ConstString.cpp
===================================================================
--- source/Utility/ConstString.cpp
+++ source/Utility/ConstString.cpp
@@ -43,8 +43,8 @@
 
   static size_t GetConstCStringLength(const char *ccstr) {
     if (ccstr != nullptr) {
-      // Since the entry is read only, and we derive the entry entirely from the
-      // pointer, we don't need the lock.
+      // Since the entry is read only, and we derive the entry entirely
+      // from the pointer, we don't need the lock.
       const StringPoolEntryType &entry = GetStringMapEntryFromKeyData(ccstr);
       return entry.getKey().size();
     }
@@ -156,8 +156,7 @@
 
   //------------------------------------------------------------------
   // Return the size in bytes that this object and any items in its
-  // collection of uniqued strings + data count values takes in
-  // memory.
+  // collection of uniqued strings + data count values takes in memory.
   //------------------------------------------------------------------
   size_t MemorySize() const {
     size_t mem_size = sizeof(Pool);
@@ -184,15 +183,14 @@
 };
 
 //----------------------------------------------------------------------
-// Frameworks and dylibs aren't supposed to have global C++
-// initializers so we hide the string pool in a static function so
-// that it will get initialized on the first call to this static
-// function.
+// Frameworks and dylibs aren't supposed to have global C++ initializers
+// so we hide the string pool in a static function so that it will get
+// initialized on the first call to this static function.
 //
-// Note, for now we make the string pool a pointer to the pool, because
-// we can't guarantee that some objects won't get destroyed after the
-// global destructor chain is run, and trying to make sure no destructors
-// touch ConstStrings is difficult.  So we leak the pool instead.
+// Note, for now we make the string pool a pointer to the pool, because we
+// can't guarantee that some objects won't get destroyed after the global
+// destructor chain is run, and trying to make sure no destructors touch
+// ConstStrings is difficult.  So we leak the pool instead.
 //----------------------------------------------------------------------
 static Pool &StringPool() {
   static llvm::once_flag g_pool_initialization_flag;
@@ -224,7 +222,8 @@
   if (lhs_string_ref.data() && rhs_string_ref.data())
     return lhs_string_ref < rhs_string_ref;
 
-  // Else one of them was nullptr, so if LHS is nullptr then it is less than
+  // Else one of them was nullptr, so if LHS is nullptr then it is less
+  // than
   return lhs_string_ref.data() == nullptr;
 }
 
@@ -245,9 +244,9 @@
   if (lhs.m_string == rhs.m_string)
     return true;
 
-  // Since the pointers weren't equal, and identical ConstStrings always have
-  // identical pointers,
-  // the result must be false for case sensitive equality test.
+  // Since the pointers weren't equal, and identical ConstStrings always
+  // have identical pointers, the result must be false for case sensitive
+  // equality test.
   if (case_sensitive)
     return false;
 
Index: source/Utility/DataBufferHeap.cpp
===================================================================
--- source/Utility/DataBufferHeap.cpp
+++ source/Utility/DataBufferHeap.cpp
@@ -22,8 +22,8 @@
 DataBufferHeap::DataBufferHeap() : m_data() {}
 
 //----------------------------------------------------------------------
-// Initialize this class with "n" characters and fill the buffer
-// with "ch".
+// Initialize this class with "n" characters and fill the buffer with
+// "ch".
 //----------------------------------------------------------------------
 DataBufferHeap::DataBufferHeap(lldb::offset_t n, uint8_t ch) : m_data() {
   if (n < m_data.max_size())
@@ -40,22 +40,22 @@
 }
 
 //----------------------------------------------------------------------
-// Virtual destructor since this class inherits from a pure virtual
-// base class.
+// Virtual destructor since this class inherits from a pure virtual base
+// class.
 //----------------------------------------------------------------------
 DataBufferHeap::~DataBufferHeap() = default;
 
 //----------------------------------------------------------------------
-// Return a pointer to the bytes owned by this object, or nullptr if
-// the object contains no bytes.
+// Return a pointer to the bytes owned by this object, or nullptr if the
+// object contains no bytes.
 //----------------------------------------------------------------------
 uint8_t *DataBufferHeap::GetBytes() {
   return (m_data.empty() ? nullptr : m_data.data());
 }
 
 //----------------------------------------------------------------------
-// Return a const pointer to the bytes owned by this object, or nullptr
-// if the object contains no bytes.
+// Return a const pointer to the bytes owned by this object, or nullptr if
+// the object contains no bytes.
 //----------------------------------------------------------------------
 const uint8_t *DataBufferHeap::GetBytes() const {
   return (m_data.empty() ? nullptr : m_data.data());
@@ -67,8 +67,8 @@
 uint64_t DataBufferHeap::GetByteSize() const { return m_data.size(); }
 
 //----------------------------------------------------------------------
-// Sets the number of bytes that this object should be able to
-// contain. This can be used prior to copying data into the buffer.
+// Sets the number of bytes that this object should be able to contain.
+// This can be used prior to copying data into the buffer.
 //----------------------------------------------------------------------
 uint64_t DataBufferHeap::SetByteSize(uint64_t new_size) {
   m_data.resize(new_size);
Index: source/Utility/DataBufferLLVM.cpp
===================================================================
--- source/Utility/DataBufferLLVM.cpp
+++ source/Utility/DataBufferLLVM.cpp
@@ -30,8 +30,8 @@
 std::shared_ptr<DataBufferLLVM>
 DataBufferLLVM::CreateSliceFromPath(const llvm::Twine &Path, uint64_t Size,
                                     uint64_t Offset) {
-  // If the file resides non-locally, pass the volatile flag so that we don't
-  // mmap it.
+  // If the file resides non-locally, pass the volatile flag so that we
+  // don't mmap it.
   bool IsVolatile = !llvm::sys::fs::is_local(Path);
 
   auto Buffer =
@@ -44,8 +44,8 @@
 
 std::shared_ptr<DataBufferLLVM>
 DataBufferLLVM::CreateFromPath(const llvm::Twine &Path) {
-  // If the file resides non-locally, pass the volatile flag so that we don't
-  // mmap it.
+  // If the file resides non-locally, pass the volatile flag so that we
+  // don't mmap it.
   bool IsVolatile = !llvm::sys::fs::is_local(Path);
 
   auto Buffer = llvm::WritableMemoryBuffer::getFile(Path, -1, IsVolatile);
Index: source/Utility/DataEncoder.cpp
===================================================================
--- source/Utility/DataEncoder.cpp
+++ source/Utility/DataEncoder.cpp
@@ -43,11 +43,11 @@
       m_byte_order(endian), m_addr_size(addr_size), m_data_sp() {}
 
 //----------------------------------------------------------------------
-// Make a shared pointer reference to the shared data in "data_sp" and
-// set the endian swapping setting to "swap", and the address size to
-// "addr_size". The shared data reference will ensure the data lives
-// as long as any DataEncoder objects exist that have a reference to
-// this data.
+// Make a shared pointer reference to the shared data in "data_sp" and set
+// the endian swapping setting to "swap", and the address size to
+// "addr_size". The shared data reference will ensure the data lives as
+// long as any DataEncoder objects exist that have a reference to this
+// data.
 //----------------------------------------------------------------------
 DataEncoder::DataEncoder(const DataBufferSP &data_sp, ByteOrder endian,
                          uint8_t addr_size)
@@ -59,9 +59,8 @@
 DataEncoder::~DataEncoder() = default;
 
 //------------------------------------------------------------------
-// Clears the object contents back to a default invalid state, and
-// release any references to shared data that this object may
-// contain.
+// Clears the object contents back to a default invalid state, and release
+// any references to shared data that this object may contain.
 //------------------------------------------------------------------
 void DataEncoder::Clear() {
   m_start = nullptr;
@@ -72,8 +71,8 @@
 }
 
 //------------------------------------------------------------------
-// If this object contains shared data, this function returns the
-// offset into that shared data. Else zero is returned.
+// If this object contains shared data, this function returns the offset
+// into that shared data. Else zero is returned.
 //------------------------------------------------------------------
 size_t DataEncoder::GetSharedDataOffset() const {
   if (m_start != nullptr) {
@@ -90,14 +89,14 @@
 }
 
 //----------------------------------------------------------------------
-// Set the data with which this object will extract from to data
-// starting at BYTES and set the length of the data to LENGTH bytes
-// long. The data is externally owned must be around at least as
-// long as this object points to the data. No copy of the data is
-// made, this object just refers to this data and can extract from
-// it. If this object refers to any shared data upon entry, the
-// reference to that data will be released. Is SWAP is set to true,
-// any data extracted will be endian swapped.
+// Set the data with which this object will extract from to data starting
+// at BYTES and set the length of the data to LENGTH bytes long. The data
+// is externally owned must be around at least as long as this object
+// points to the data. No copy of the data is made, this object just
+// refers to this data and can extract from it. If this object refers to
+// any shared data upon entry, the reference to that data will be
+// released. Is SWAP is set to true, any data extracted will be endian
+// swapped.
 //----------------------------------------------------------------------
 uint32_t DataEncoder::SetData(void *bytes, uint32_t length, ByteOrder endian) {
   m_byte_order = endian;
@@ -113,17 +112,16 @@
 }
 
 //----------------------------------------------------------------------
-// Assign the data for this object to be a subrange of the shared
-// data in "data_sp" starting "data_offset" bytes into "data_sp"
-// and ending "data_length" bytes later. If "data_offset" is not
-// a valid offset into "data_sp", then this object will contain no
-// bytes. If "data_offset" is within "data_sp" yet "data_length" is
-// too large, the length will be capped at the number of bytes
-// remaining in "data_sp". A ref counted pointer to the data in
-// "data_sp" will be made in this object IF the number of bytes this
-// object refers to in greater than zero (if at least one byte was
-// available starting at "data_offset") to ensure the data stays
-// around as long as it is needed. The address size and endian swap
+// Assign the data for this object to be a subrange of the shared data in
+// "data_sp" starting "data_offset" bytes into "data_sp" and ending
+// "data_length" bytes later. If "data_offset" is not a valid offset into
+// "data_sp", then this object will contain no bytes. If "data_offset" is
+// within "data_sp" yet "data_length" is too large, the length will be
+// capped at the number of bytes remaining in "data_sp". A ref counted
+// pointer to the data in "data_sp" will be made in this object IF the
+// number of bytes this object refers to in greater than zero (if at least
+// one byte was available starting at "data_offset") to ensure the data
+// stays around as long as it is needed. The address size and endian swap
 // settings will remain unchanged from their current settings.
 //----------------------------------------------------------------------
 uint32_t DataEncoder::SetData(const DataBufferSP &data_sp, uint32_t data_offset,
@@ -149,8 +147,8 @@
 
   uint32_t new_size = GetByteSize();
 
-  // Don't hold a shared pointer to the data buffer if we don't share
-  // any valid bytes in the shared buffer.
+  // Don't hold a shared pointer to the data buffer if we don't share any
+  // valid bytes in the shared buffer.
   if (new_size == 0)
     m_data_sp.reset();
 
@@ -158,8 +156,8 @@
 }
 
 //----------------------------------------------------------------------
-// Extract a single unsigned char from the binary data and update
-// the offset pointed to by "offset_ptr".
+// Extract a single unsigned char from the binary data and update the
+// offset pointed to by "offset_ptr".
 //
 // RETURNS the byte that was extracted, or zero on failure.
 //----------------------------------------------------------------------
@@ -209,11 +207,11 @@
 
 //----------------------------------------------------------------------
 // Extract a single integer value from the data and update the offset
-// pointed to by "offset_ptr". The size of the extracted integer
-// is specified by the "byte_size" argument. "byte_size" should have
-// a value >= 1 and <= 8 since the return value is only 64 bits
-// wide. Any "byte_size" values less than 1 or greater than 8 will
-// result in nothing being extracted, and zero being returned.
+// pointed to by "offset_ptr". The size of the extracted integer is
+// specified by the "byte_size" argument. "byte_size" should have a value
+// >= 1 and <= 8 since the return value is only 64 bits wide. Any
+// "byte_size" values less than 1 or greater than 8 will result in nothing
+// being extracted, and zero being returned.
 //
 // RETURNS the integer value that was extracted, or zero on failure.
 //----------------------------------------------------------------------
Index: source/Utility/DataExtractor.cpp
===================================================================
--- source/Utility/DataExtractor.cpp
+++ source/Utility/DataExtractor.cpp
@@ -143,11 +143,11 @@
 }
 
 //----------------------------------------------------------------------
-// Make a shared pointer reference to the shared data in "data_sp" and
-// set the endian swapping setting to "swap", and the address size to
-// "addr_size". The shared data reference will ensure the data lives
-// as long as any DataExtractor objects exist that have a reference to
-// this data.
+// Make a shared pointer reference to the shared data in "data_sp" and set
+// the endian swapping setting to "swap", and the address size to
+// "addr_size". The shared data reference will ensure the data lives as
+// long as any DataExtractor objects exist that have a reference to this
+// data.
 //----------------------------------------------------------------------
 DataExtractor::DataExtractor(const DataBufferSP &data_sp, ByteOrder endian,
                              uint32_t addr_size,
@@ -162,11 +162,11 @@
 }
 
 //----------------------------------------------------------------------
-// Initialize this object with a subset of the data bytes in "data".
-// If "data" contains shared data, then a reference to this shared
-// data will added and the shared data will stay around as long
-// as any object contains a reference to that data. The endian
-// swap and address size settings are copied from "data".
+// Initialize this object with a subset of the data bytes in "data". If
+// "data" contains shared data, then a reference to this shared data will
+// added and the shared data will stay around as long as any object
+// contains a reference to that data. The endian swap and address size
+// settings are copied from "data".
 //----------------------------------------------------------------------
 DataExtractor::DataExtractor(const DataExtractor &data, offset_t offset,
                              offset_t length, uint32_t target_byte_size /*=1*/)
@@ -210,9 +210,8 @@
 DataExtractor::~DataExtractor() = default;
 
 //------------------------------------------------------------------
-// Clears the object contents back to a default invalid state, and
-// release any references to shared data that this object may
-// contain.
+// Clears the object contents back to a default invalid state, and release
+// any references to shared data that this object may contain.
 //------------------------------------------------------------------
 void DataExtractor::Clear() {
   m_start = nullptr;
@@ -223,8 +222,8 @@
 }
 
 //------------------------------------------------------------------
-// If this object contains shared data, this function returns the
-// offset into that shared data. Else zero is returned.
+// If this object contains shared data, this function returns the offset
+// into that shared data. Else zero is returned.
 //------------------------------------------------------------------
 size_t DataExtractor::GetSharedDataOffset() const {
   if (m_start != nullptr) {
@@ -241,14 +240,14 @@
 }
 
 //----------------------------------------------------------------------
-// Set the data with which this object will extract from to data
-// starting at BYTES and set the length of the data to LENGTH bytes
-// long. The data is externally owned must be around at least as
-// long as this object points to the data. No copy of the data is
-// made, this object just refers to this data and can extract from
-// it. If this object refers to any shared data upon entry, the
-// reference to that data will be released. Is SWAP is set to true,
-// any data extracted will be endian swapped.
+// Set the data with which this object will extract from to data starting
+// at BYTES and set the length of the data to LENGTH bytes long. The data
+// is externally owned must be around at least as long as this object
+// points to the data. No copy of the data is made, this object just
+// refers to this data and can extract from it. If this object refers to
+// any shared data upon entry, the reference to that data will be
+// released. Is SWAP is set to true, any data extracted will be endian
+// swapped.
 //----------------------------------------------------------------------
 lldb::offset_t DataExtractor::SetData(const void *bytes, offset_t length,
                                       ByteOrder endian) {
@@ -265,17 +264,16 @@
 }
 
 //----------------------------------------------------------------------
-// Assign the data for this object to be a subrange in "data"
-// starting "data_offset" bytes into "data" and ending "data_length"
-// bytes later. If "data_offset" is not a valid offset into "data",
-// then this object will contain no bytes. If "data_offset" is
-// within "data" yet "data_length" is too large, the length will be
-// capped at the number of bytes remaining in "data". If "data"
-// contains a shared pointer to other data, then a ref counted
-// pointer to that data will be made in this object. If "data"
-// doesn't contain a shared pointer to data, then the bytes referred
-// to in "data" will need to exist at least as long as this object
-// refers to those bytes. The address size and endian swap settings
+// Assign the data for this object to be a subrange in "data" starting
+// "data_offset" bytes into "data" and ending "data_length" bytes later.
+// If "data_offset" is not a valid offset into "data", then this object
+// will contain no bytes. If "data_offset" is within "data" yet
+// "data_length" is too large, the length will be capped at the number of
+// bytes remaining in "data". If "data" contains a shared pointer to other
+// data, then a ref counted pointer to that data will be made in this
+// object. If "data" doesn't contain a shared pointer to data, then the
+// bytes referred to in "data" will need to exist at least as long as this
+// object refers to those bytes. The address size and endian swap settings
 // are copied from the current values in "data".
 //----------------------------------------------------------------------
 lldb::offset_t DataExtractor::SetData(const DataExtractor &data,
@@ -303,17 +301,16 @@
 }
 
 //----------------------------------------------------------------------
-// Assign the data for this object to be a subrange of the shared
-// data in "data_sp" starting "data_offset" bytes into "data_sp"
-// and ending "data_length" bytes later. If "data_offset" is not
-// a valid offset into "data_sp", then this object will contain no
-// bytes. If "data_offset" is within "data_sp" yet "data_length" is
-// too large, the length will be capped at the number of bytes
-// remaining in "data_sp". A ref counted pointer to the data in
-// "data_sp" will be made in this object IF the number of bytes this
-// object refers to in greater than zero (if at least one byte was
-// available starting at "data_offset") to ensure the data stays
-// around as long as it is needed. The address size and endian swap
+// Assign the data for this object to be a subrange of the shared data in
+// "data_sp" starting "data_offset" bytes into "data_sp" and ending
+// "data_length" bytes later. If "data_offset" is not a valid offset into
+// "data_sp", then this object will contain no bytes. If "data_offset" is
+// within "data_sp" yet "data_length" is too large, the length will be
+// capped at the number of bytes remaining in "data_sp". A ref counted
+// pointer to the data in "data_sp" will be made in this object IF the
+// number of bytes this object refers to in greater than zero (if at least
+// one byte was available starting at "data_offset") to ensure the data
+// stays around as long as it is needed. The address size and endian swap
 // settings will remain unchanged from their current settings.
 //----------------------------------------------------------------------
 lldb::offset_t DataExtractor::SetData(const DataBufferSP &data_sp,
@@ -340,8 +337,8 @@
 
   size_t new_size = GetByteSize();
 
-  // Don't hold a shared pointer to the data buffer if we don't share
-  // any valid bytes in the shared buffer.
+  // Don't hold a shared pointer to the data buffer if we don't share any
+  // valid bytes in the shared buffer.
   if (new_size == 0)
     m_data_sp.reset();
 
@@ -349,8 +346,8 @@
 }
 
 //----------------------------------------------------------------------
-// Extract a single unsigned char from the binary data and update
-// the offset pointed to by "offset_ptr".
+// Extract a single unsigned char from the binary data and update the
+// offset pointed to by "offset_ptr".
 //
 // RETURNS the byte that was extracted, or zero on failure.
 //----------------------------------------------------------------------
@@ -376,16 +373,16 @@
   if (data) {
     // Copy the data into the buffer
     memcpy(dst, data, count);
-    // Return a non-nullptr pointer to the converted data as an indicator of
-    // success
+    // Return a non-nullptr pointer to the converted data as an indicator
+    // of success
     return dst;
   }
   return nullptr;
 }
 
 //----------------------------------------------------------------------
-// Extract a single uint16_t from the data and update the offset
-// pointed to by "offset_ptr".
+// Extract a single uint16_t from the data and update the offset pointed
+// to by "offset_ptr".
 //
 // RETURNS the uint16_t that was extracted, or zero on failure.
 //----------------------------------------------------------------------
@@ -432,13 +429,13 @@
 }
 
 //----------------------------------------------------------------------
-// Extract "count" uint16_t values from the binary data and update
-// the offset pointed to by "offset_ptr". The extracted data is
-// copied into "dst".
+// Extract "count" uint16_t values from the binary data and update the
+// offset pointed to by "offset_ptr". The extracted data is copied into
+// "dst".
 //
 // RETURNS the non-nullptr buffer pointer upon successful extraction of
-// all the requested bytes, or nullptr when the data is not available
-// in the buffer due to being out of bounds, or insufficient data.
+// all the requested bytes, or nullptr when the data is not available in
+// the buffer due to being out of bounds, or insufficient data.
 //----------------------------------------------------------------------
 void *DataExtractor::GetU16(offset_t *offset_ptr, void *void_dst,
                             uint32_t count) const {
@@ -457,16 +454,16 @@
     } else {
       memcpy(void_dst, src, src_size);
     }
-    // Return a non-nullptr pointer to the converted data as an indicator of
-    // success
+    // Return a non-nullptr pointer to the converted data as an indicator
+    // of success
     return void_dst;
   }
   return nullptr;
 }
 
 //----------------------------------------------------------------------
-// Extract a single uint32_t from the data and update the offset
-// pointed to by "offset_ptr".
+// Extract a single uint32_t from the data and update the offset pointed
+// to by "offset_ptr".
 //
 // RETURNS the uint32_t that was extracted, or zero on failure.
 //----------------------------------------------------------------------
@@ -484,13 +481,13 @@
 }
 
 //----------------------------------------------------------------------
-// Extract "count" uint32_t values from the binary data and update
-// the offset pointed to by "offset_ptr". The extracted data is
-// copied into "dst".
+// Extract "count" uint32_t values from the binary data and update the
+// offset pointed to by "offset_ptr". The extracted data is copied into
+// "dst".
 //
 // RETURNS the non-nullptr buffer pointer upon successful extraction of
-// all the requested bytes, or nullptr when the data is not available
-// in the buffer due to being out of bounds, or insufficient data.
+// all the requested bytes, or nullptr when the data is not available in
+// the buffer due to being out of bounds, or insufficient data.
 //----------------------------------------------------------------------
 void *DataExtractor::GetU32(offset_t *offset_ptr, void *void_dst,
                             uint32_t count) const {
@@ -509,16 +506,16 @@
     } else {
       memcpy(void_dst, src, src_size);
     }
-    // Return a non-nullptr pointer to the converted data as an indicator of
-    // success
+    // Return a non-nullptr pointer to the converted data as an indicator
+    // of success
     return void_dst;
   }
   return nullptr;
 }
 
 //----------------------------------------------------------------------
-// Extract a single uint64_t from the data and update the offset
-// pointed to by "offset_ptr".
+// Extract a single uint64_t from the data and update the offset pointed
+// to by "offset_ptr".
 //
 // RETURNS the uint64_t that was extracted, or zero on failure.
 //----------------------------------------------------------------------
@@ -538,9 +535,9 @@
 //----------------------------------------------------------------------
 // GetU64
 //
-// Get multiple consecutive 64 bit values. Return true if the entire
-// read succeeds and increment the offset pointed to by offset_ptr, else
-// return false and leave the offset pointed to by offset_ptr unchanged.
+// Get multiple consecutive 64 bit values. Return true if the entire read
+// succeeds and increment the offset pointed to by offset_ptr, else return
+// false and leave the offset pointed to by offset_ptr unchanged.
 //----------------------------------------------------------------------
 void *DataExtractor::GetU64(offset_t *offset_ptr, void *void_dst,
                             uint32_t count) const {
@@ -559,8 +556,8 @@
     } else {
       memcpy(void_dst, src, src_size);
     }
-    // Return a non-nullptr pointer to the converted data as an indicator of
-    // success
+    // Return a non-nullptr pointer to the converted data as an indicator
+    // of success
     return void_dst;
   }
   return nullptr;
@@ -708,10 +705,10 @@
 }
 
 //------------------------------------------------------------------
-// Extract a single address from the data and update the offset
-// pointed to by "offset_ptr". The size of the extracted address
-// comes from the "this->m_addr_size" member variable and should be
-// set correctly prior to extracting any address values.
+// Extract a single address from the data and update the offset pointed to
+// by "offset_ptr". The size of the extracted address comes from the
+// "this->m_addr_size" member variable and should be set correctly prior
+// to extracting any address values.
 //
 // RETURNS the address that was extracted, or zero on failure.
 //------------------------------------------------------------------
@@ -730,10 +727,10 @@
 }
 
 //------------------------------------------------------------------
-// Extract a single pointer from the data and update the offset
-// pointed to by "offset_ptr". The size of the extracted pointer
-// comes from the "this->m_addr_size" member variable and should be
-// set correctly prior to extracting any pointer values.
+// Extract a single pointer from the data and update the offset pointed to
+// by "offset_ptr". The size of the extracted pointer comes from the
+// "this->m_addr_size" member variable and should be set correctly prior
+// to extracting any pointer values.
 //
 // RETURNS the pointer that was extracted, or zero on failure.
 //------------------------------------------------------------------
@@ -804,9 +801,9 @@
   const uint8_t *src = (const uint8_t *)PeekData(src_offset, src_len);
   if (src) {
     if (dst_len >= src_len) {
-      // We are copying the entire value from src into dst.
-      // Calculate how many, if any, zeroes we need for the most
-      // significant bytes if "dst_len" is greater than "src_len"...
+      // We are copying the entire value from src into dst. Calculate how
+      // many, if any, zeroes we need for the most significant bytes if
+      // "dst_len" is greater than "src_len"...
       const size_t num_zeroes = dst_len - src_len;
       if (dst_byte_order == eByteOrderBig) {
         // Big endian, so we lead with zeroes...
@@ -863,15 +860,14 @@
 }
 
 //----------------------------------------------------------------------
-// Extracts a variable length NULL terminated C string from
-// the data at the offset pointed to by "offset_ptr".  The
-// "offset_ptr" will be updated with the offset of the byte that
-// follows the NULL terminator byte.
+// Extracts a variable length NULL terminated C string from the data at
+// the offset pointed to by "offset_ptr".  The "offset_ptr" will be
+// updated with the offset of the byte that follows the NULL terminator
+// byte.
 //
 // If the offset pointed to by "offset_ptr" is out of bounds, or if
-// "length" is non-zero and there aren't enough available
-// bytes, nullptr will be returned and "offset_ptr" will not be
-// updated.
+// "length" is non-zero and there aren't enough available bytes, nullptr
+// will be returned and "offset_ptr" will not be updated.
 //----------------------------------------------------------------------
 const char *DataExtractor::GetCStr(offset_t *offset_ptr) const {
   const char *cstr = (const char *)PeekData(*offset_ptr, 1);
@@ -881,8 +877,8 @@
     while (cstr_end < end && *cstr_end)
       ++cstr_end;
 
-    // Now we are either at the end of the data or we point to the
-    // NULL C string terminator with cstr_end...
+    // Now we are either at the end of the data or we point to the NULL C
+    // string terminator with cstr_end...
     if (*cstr_end == '\0') {
       // Advance the offset with one extra byte for the NULL terminator
       *offset_ptr += (cstr_end - cstr + 1);
@@ -891,22 +887,22 @@
 
     // We reached the end of the data without finding a NULL C string
     // terminator. Fall through and return nullptr otherwise anyone that
-    // would have used the result as a C string can wander into
-    // unknown memory...
+    // would have used the result as a C string can wander into unknown
+    // memory...
   }
   return nullptr;
 }
 
 //----------------------------------------------------------------------
 // Extracts a NULL terminated C string from the fixed length field of
-// length "len" at the offset pointed to by "offset_ptr".
-// The "offset_ptr" will be updated with the offset of the byte that
-// follows the fixed length field.
+// length "len" at the offset pointed to by "offset_ptr". The "offset_ptr"
+// will be updated with the offset of the byte that follows the fixed
+// length field.
 //
-// If the offset pointed to by "offset_ptr" is out of bounds, or if
-// the offset plus the length of the field is out of bounds, or if the
-// field does not contain a NULL terminator byte, nullptr will be returned
-// and "offset_ptr" will not be updated.
+// If the offset pointed to by "offset_ptr" is out of bounds, or if the
+// offset plus the length of the field is out of bounds, or if the field
+// does not contain a NULL terminator byte, nullptr will be returned and
+// "offset_ptr" will not be updated.
 //----------------------------------------------------------------------
 const char *DataExtractor::GetCStr(offset_t *offset_ptr, offset_t len) const {
   const char *cstr = (const char *)PeekData(*offset_ptr, len);
@@ -921,22 +917,22 @@
 }
 
 //------------------------------------------------------------------
-// Peeks at a string in the contained data. No verification is done
-// to make sure the entire string lies within the bounds of this
-// object's data, only "offset" is verified to be a valid offset.
+// Peeks at a string in the contained data. No verification is done to
+// make sure the entire string lies within the bounds of this object's
+// data, only "offset" is verified to be a valid offset.
 //
-// Returns a valid C string pointer if "offset" is a valid offset in
-// this object's data, else nullptr is returned.
+// Returns a valid C string pointer if "offset" is a valid offset in this
+// object's data, else nullptr is returned.
 //------------------------------------------------------------------
 const char *DataExtractor::PeekCStr(offset_t offset) const {
   return (const char *)PeekData(offset, 1);
 }
 
 //----------------------------------------------------------------------
-// Extracts an unsigned LEB128 number from this object's data
-// starting at the offset pointed to by "offset_ptr". The offset
-// pointed to by "offset_ptr" will be updated with the offset of the
-// byte following the last extracted byte.
+// Extracts an unsigned LEB128 number from this object's data starting at
+// the offset pointed to by "offset_ptr". The offset pointed to by
+// "offset_ptr" will be updated with the offset of the byte following the
+// last extracted byte.
 //
 // Returned the extracted integer value.
 //----------------------------------------------------------------------
@@ -968,10 +964,10 @@
 }
 
 //----------------------------------------------------------------------
-// Extracts an signed LEB128 number from this object's data
-// starting at the offset pointed to by "offset_ptr". The offset
-// pointed to by "offset_ptr" will be updated with the offset of the
-// byte following the last extracted byte.
+// Extracts an signed LEB128 number from this object's data starting at
+// the offset pointed to by "offset_ptr". The offset pointed to by
+// "offset_ptr" will be updated with the offset of the byte following the
+// last extracted byte.
 //
 // Returned the extracted integer value.
 //----------------------------------------------------------------------
@@ -1010,10 +1006,10 @@
 }
 
 //----------------------------------------------------------------------
-// Skips a ULEB128 number (signed or unsigned) from this object's
-// data starting at the offset pointed to by "offset_ptr". The
-// offset pointed to by "offset_ptr" will be updated with the offset
-// of the byte following the last extracted byte.
+// Skips a ULEB128 number (signed or unsigned) from this object's data
+// starting at the offset pointed to by "offset_ptr". The offset pointed
+// to by "offset_ptr" will be updated with the offset of the byte
+// following the last extracted byte.
 //
 // Returns the number of bytes consumed during the extraction.
 //----------------------------------------------------------------------
@@ -1036,15 +1032,14 @@
 
 //----------------------------------------------------------------------
 // Dumps bytes from this object's data to the stream "s" starting
-// "start_offset" bytes into this data, and ending with the byte
-// before "end_offset". "base_addr" will be added to the offset
-// into the dumped data when showing the offset into the data in the
-// output information. "num_per_line" objects of type "type" will
-// be dumped with the option to override the format for each object
-// with "type_format". "type_format" is a printf style formatting
-// string. If "type_format" is nullptr, then an appropriate format
-// string will be used for the supplied "type". If the stream "s"
-// is nullptr, then the output will be send to Log().
+// "start_offset" bytes into this data, and ending with the byte before
+// "end_offset". "base_addr" will be added to the offset into the dumped
+// data when showing the offset into the data in the output information.
+// "num_per_line" objects of type "type" will be dumped with the option to
+// override the format for each object with "type_format". "type_format"
+// is a printf style formatting string. If "type_format" is nullptr, then
+// an appropriate format string will be used for the supplied "type". If
+// the stream "s" is nullptr, then the output will be send to Log().
 //----------------------------------------------------------------------
 lldb::offset_t DataExtractor::PutToLog(Log *log, offset_t start_offset,
                                        offset_t length, uint64_t base_addr,
@@ -1066,7 +1061,8 @@
         log->PutString(sstr.GetString());
         sstr.Clear();
       }
-      // Reset string offset and fill the current line string with address:
+      // Reset string offset and fill the current line string with
+      // address:
       if (base_addr != LLDB_INVALID_ADDRESS)
         sstr.Printf("0x%8.8" PRIx64 ":",
                     (uint64_t)(base_addr + (offset - start_offset)));
Index: source/Utility/FastDemangle.cpp
===================================================================
--- source/Utility/FastDemangle.cpp
+++ source/Utility/FastDemangle.cpp
@@ -200,8 +200,8 @@
     if (growth > 1 << 20)
       growth = 1 << 20;
 
-    // ... but never grow by less than requested,
-    // or 1K, whichever is greater
+    // ... but never grow by less than requested, or 1K, whichever is
+    // greater
     if (min_growth < 1024)
       min_growth = 1024;
     if (growth < min_growth)
@@ -324,8 +324,8 @@
   }
 
   void ResetTemplateArgs() {
-    // TODO: this works, but is it the right thing to do?
-    // Should we push/pop somehow at the call sites?
+    // TODO: this works, but is it the right thing to do? Should we
+    // push/pop somehow at the call sites?
     m_next_template_arg_index = m_rewrite_ranges_size - 1;
   }
 
@@ -402,8 +402,8 @@
   //----------------------------------------------------
   // Rewrite methods
   //
-  // Write another copy of content already present
-  // earlier in the output buffer
+  // Write another copy of content already present earlier in the output
+  // buffer
   //----------------------------------------------------
 
   void RewriteRange(BufferRange range) {
@@ -436,11 +436,11 @@
   //----------------------------------------------------
   // TryParse methods
   //
-  // Provide information with return values instead of
-  // writing to the output buffer
+  // Provide information with return values instead of writing to the
+  // output buffer
   //
-  // Values indicating failure guarantee that the pre-
-  // call m_read_ptr is unchanged
+  // Values indicating failure guarantee that the pre- call m_read_ptr is
+  // unchanged
   //----------------------------------------------------
 
   int TryParseNumber() {
@@ -820,8 +820,8 @@
   }
 
   // <CV-qualifiers> ::= [r] [V] [K]
-  // <ref-qualifier> ::= R                   # & ref-qualifier
-  // <ref-qualifier> ::= O                   # && ref-qualifier
+  // <ref-qualifier> ::= R                   # & ref-qualifier <ref-
+  // qualifier> ::= O                   # && ref-qualifier
 
   int TryParseQualifiers(bool allow_cv, bool allow_ro) {
     int qualifiers = QualifierNone;
@@ -890,11 +890,11 @@
   //----------------------------------------------------
   // Parse methods
   //
-  // Consume input starting from m_read_ptr and produce
-  // buffered output at m_write_ptr
+  // Consume input starting from m_read_ptr and produce buffered output at
+  // m_write_ptr
   //
-  // Failures return false and may leave m_read_ptr in an
-  // indeterminate state
+  // Failures return false and may leave m_read_ptr in an indeterminate
+  // state
   //----------------------------------------------------
 
   bool Parse(char character) {
@@ -932,17 +932,15 @@
 
   // <substitution> ::= S <seq-id> _
   //                ::= S_
-  // <substitution> ::= Sa # ::std::allocator
-  // <substitution> ::= Sb # ::std::basic_string
-  // <substitution> ::= Ss # ::std::basic_string < char,
+  // <substitution> ::= Sa # ::std::allocator <substitution> ::= Sb #
+  // ::std::basic_string <substitution> ::= Ss # ::std::basic_string <
+  // char,
   //                                               ::std::char_traits<char>,
   //                                               ::std::allocator<char> >
-  // <substitution> ::= Si # ::std::basic_istream<char,  std::char_traits<char>
-  // >
-  // <substitution> ::= So # ::std::basic_ostream<char,  std::char_traits<char>
-  // >
-  // <substitution> ::= Sd # ::std::basic_iostream<char, std::char_traits<char>
-  // >
+  // <substitution> ::= Si # ::std::basic_istream<char,
+  // std::char_traits<char> > <substitution> ::= So #
+  // ::std::basic_ostream<char,  std::char_traits<char> > <substitution>
+  // ::= Sd # ::std::basic_iostream<char, std::char_traits<char> >
 
   bool ParseSubstitution() {
     const char *substitution;
@@ -966,8 +964,9 @@
       substitution = "std::iostream";
       break;
     default:
-      // A failed attempt to parse a number will return -1 which turns out to be
-      // perfect here as S_ is the first substitution, S0_ the next and so forth
+      // A failed attempt to parse a number will return -1 which turns out
+      // to be perfect here as S_ is the first substitution, S0_ the next
+      // and so forth
       int substitution_index = TryParseBase36Number();
       if (*m_read_ptr++ != '_') {
 #ifdef DEBUG_FAILURES
@@ -984,17 +983,17 @@
 
   // <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E
   //
-  // <bare-function-type> ::= <signature type>+      # types are possible return
-  // type, then parameter types
+  // <bare-function-type> ::= <signature type>+      # types are possible
+  // return type, then parameter types
 
   bool ParseFunctionType(int inner_qualifiers = QualifierNone) {
 #ifdef DEBUG_FAILURES
     printf("*** Function types not supported\n");
 #endif
     // TODO: first steps toward an implementation follow, but they're far
-    // from complete.  Function types tend to bracket other types eg:
-    // int (*)() when used as the type for "name" becomes int (*name)().
-    // This makes substitution et al ... interesting.
+    // from complete.  Function types tend to bracket other types eg: int
+    // (*)() when used as the type for "name" becomes int (*name)(). This
+    // makes substitution et al ... interesting.
     return false;
 
 #if 0  // TODO
@@ -1073,8 +1072,8 @@
     // templates and trying to constify them eg:
     // _ZN4llvm2cl5applyIA28_cNS0_3optIbLb0ENS0_6parserIbEEEEEEvRKT_PT0_
     //
-    // TODO: Chances are we don't do any better with references and pointers
-    // that should be type (&) [] instead of type & []
+    // TODO: Chances are we don't do any better with references and
+    // pointers that should be type (&) [] instead of type & []
 
     return false;
 
@@ -1154,8 +1153,8 @@
     if (!Parse('_'))
       return false;
 
-    // When no number is present we get -1, which is convenient since
-    // T_ is the zeroth element T0_ is element 1, and so on
+    // When no number is present we get -1, which is convenient since T_
+    // is the zeroth element T0_ is element 1, and so on
     return RewriteTemplateArg(count + 1);
   }
 
@@ -1196,10 +1195,10 @@
   // extension := U <objc-name> <objc-type>  # objc-type<identifier>
   // extension := <vector-type> # <vector-type> starts with Dv
 
-  // <objc-name> ::= <k0 number> objcproto <k1 number> <identifier>  # k0 = 9 +
-  // <number of digits in k1> + k1
-  // <objc-type> := <source-name>  # PU<11+>objcproto 11objc_object<source-name>
-  // 11objc_object -> id<source-name>
+  // <objc-name> ::= <k0 number> objcproto <k1 number> <identifier>  # k0
+  // = 9 + <number of digits in k1> + k1 <objc-type> := <source-name>  #
+  // PU<11+>objcproto 11objc_object<source-name> 11objc_object -> id
+  // <source-name>
 
   bool ParseType() {
 #ifdef DEBUG_FAILURES
@@ -1333,8 +1332,8 @@
   //
   // <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
   //
-  // <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda
-  // has no parameters
+  // <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the
+  // lambda has no parameters
 
   bool ParseUnnamedTypeName(NameState &name_state) {
     switch (*m_read_ptr++) {
@@ -1551,8 +1550,8 @@
     return Parse('E');
   }
 
-  // <expr-primary> ::= L <type> <value number> E                          #
-  // integer literal
+  // <expr-primary> ::= L <type> <value number> E
+  // # integer literal
   //                ::= L <type> <value float> E                           #
   //                floating literal
   //                ::= L <string type> E                                  #
@@ -1657,8 +1656,8 @@
     }
   }
 
-  // <base-unresolved-name> ::= <simple-id>                                #
-  // unresolved name
+  // <base-unresolved-name> ::= <simple-id>
+  // # unresolved name
   //          extension     ::= <operator-name>                            #
   //          unresolved operator-function-id
   //          extension     ::= <operator-name> <template-args>            #
@@ -1852,8 +1851,8 @@
     }
   }
 
-  // <template-arg> ::= <type>                                             #
-  // type or template
+  // <template-arg> ::= <type>
+  // # type or template
   //                ::= X <expression> E                                   #
   //                expression
   //                ::= <expr-primary>                                     #
@@ -1943,7 +1942,8 @@
         break;
       }
 
-      // Record a substitution candidate for all prefixes, but not the full name
+      // Record a substitution candidate for all prefixes, but not the
+      // full name
       if (suppress_substitution)
         suppress_substitution = false;
       else
@@ -2045,7 +2045,8 @@
     return true;
   }
 
-  // <local-name> := Z <function encoding> E <entity name> [<discriminator>]
+  // <local-name> := Z <function encoding> E <entity name>
+  // [<discriminator>]
   //              := Z <function encoding> E s [<discriminator>]
   //              := Z <function encoding> Ed [ <parameter number> ] _ <entity
   //              name>
@@ -2239,17 +2240,17 @@
     return true;
   }
 
-  // <bare-function-type> ::= <signature type>+        # types are possible
-  // return type, then parameter types
+  // <bare-function-type> ::= <signature type>+        # types are
+  // possible return type, then parameter types
 
   bool ParseFunctionArgs(NameState &name_state, int return_insert_cookie) {
     char next = *m_read_ptr;
     if (next == 'E' || next == '\0' || next == '.')
       return true;
 
-    // Clang has a bad habit of making unique manglings by just sticking numbers
-    // on the end of a symbol,
-    // which is ambiguous with malformed source name manglings
+    // Clang has a bad habit of making unique manglings by just sticking
+    // numbers on the end of a symbol, which is ambiguous with malformed
+    // source name manglings
     const char *before_clang_uniquing_test = m_read_ptr;
     if (TryParseNumber()) {
       if (*m_read_ptr == '\0')
@@ -2277,8 +2278,8 @@
         ++m_read_ptr;
         continue;
       case '_':
-        // Not a formal part of the mangling specification, but clang emits
-        // suffixes starting with _block_invoke
+        // Not a formal part of the mangling specification, but clang
+        // emits suffixes starting with _block_invoke
         if (strncmp(m_read_ptr, "_block_invoke", 13) == 0) {
           m_read_ptr += strlen(m_read_ptr);
           break;
Index: source/Utility/FileSpec.cpp
===================================================================
--- source/Utility/FileSpec.cpp
+++ source/Utility/FileSpec.cpp
@@ -67,8 +67,8 @@
     return;
 
   std::replace(path.begin(), path.end(), '\\', '/');
-  // Windows path can have \\ slashes which can be changed by replace
-  // call above to //. Here we remove the duplicate.
+  // Windows path can have \\ slashes which can be changed by replace call
+  // above to //. Here we remove the duplicate.
   auto iter = std::unique(path.begin(), path.end(), [](char &c1, char &c2) {
     return (c1 == '/' && c2 == '/');
   });
@@ -166,8 +166,8 @@
 FileSpec::FileSpec() : m_syntax(GetNativeSyntax()) {}
 
 //------------------------------------------------------------------
-// Default constructor that can take an optional full path to a
-// file on disk.
+// Default constructor that can take an optional full path to a file on
+// disk.
 //------------------------------------------------------------------
 FileSpec::FileSpec(llvm::StringRef path, bool resolve_path, PathSyntax syntax)
     : m_syntax(syntax) {
@@ -213,16 +213,17 @@
 }
 
 //------------------------------------------------------------------
-// Update the contents of this object with a new path. The path will
-// be split up into a directory and filename and stored as uniqued
-// string values for quick comparison and efficient memory usage.
+// Update the contents of this object with a new path. The path will be
+// split up into a directory and filename and stored as uniqued string
+// values for quick comparison and efficient memory usage.
 //------------------------------------------------------------------
 void FileSpec::SetFile(llvm::StringRef pathname, bool resolve,
                        PathSyntax syntax) {
-  // CLEANUP: Use StringRef for string handling.  This function is kind of a
-  // mess and the unclear semantics of RootDirStart and ParentPathEnd make
-  // it very difficult to understand this function.  There's no reason this
-  // function should be particularly complicated or difficult to understand.
+  // CLEANUP: Use StringRef for string handling.  This function is kind of
+  // a mess and the unclear semantics of RootDirStart and ParentPathEnd
+  // make it very difficult to understand this function.  There's no
+  // reason this function should be particularly complicated or difficult
+  // to understand.
   m_filename.Clear();
   m_directory.Clear();
   m_is_resolved = false;
@@ -278,8 +279,8 @@
 FileSpec::operator bool() const { return m_filename || m_directory; }
 
 //----------------------------------------------------------------------
-// Logical NOT operator. This allows code to check any FileSpec
-// objects to see if they are invalid using code such as:
+// Logical NOT operator. This allows code to check any FileSpec objects to
+// see if they are invalid using code such as:
 //
 //  if (!file_spec)
 //  {}
@@ -305,13 +306,11 @@
   if (DirectoryEquals(rhs))
     return true;
 
-  // TODO: determine if we want to keep this code in here.
-  // The code below was added to handle a case where we were
-  // trying to set a file and line breakpoint and one path
-  // was resolved, and the other not and the directory was
-  // in a mount point that resolved to a more complete path:
-  // "/tmp/a.c" == "/private/tmp/a.c". I might end up pulling
-  // this out...
+  // TODO: determine if we want to keep this code in here. The code below
+  // was added to handle a case where we were trying to set a file and
+  // line breakpoint and one path was resolved, and the other not and the
+  // directory was in a mount point that resolved to a more complete path:
+  // "/tmp/a.c" == "/private/tmp/a.c". I might end up pulling this out...
   if (IsResolved() && rhs.IsResolved()) {
     // Both paths are resolved, no need to look further...
     return false;
@@ -323,8 +322,8 @@
   if (!IsResolved()) {
     if (resolved_lhs.ResolvePath()) {
       // This path wasn't resolved but now it is. Check if the resolved
-      // directory is the same as our unresolved directory, and if so,
-      // we can mark this object as resolved to avoid more future resolves
+      // directory is the same as our unresolved directory, and if so, we
+      // can mark this object as resolved to avoid more future resolves
       m_is_resolved = (m_directory == resolved_lhs.m_directory);
     } else
       return false;
@@ -368,8 +367,8 @@
 }
 
 //------------------------------------------------------------------
-// Clear this object by releasing both the directory and filename
-// string values and making them both the empty string.
+// Clear this object by releasing both the directory and filename string
+// values and making them both the empty string.
 //------------------------------------------------------------------
 void FileSpec::Clear() {
   m_directory.Clear();
@@ -377,15 +376,15 @@
 }
 
 //------------------------------------------------------------------
-// Compare two FileSpec objects. If "full" is true, then both
-// the directory and the filename must match. If "full" is false,
-// then the directory names for "a" and "b" are only compared if
-// they are both non-empty. This allows a FileSpec object to only
-// contain a filename and it can match FileSpec objects that have
-// matching filenames with different paths.
+// Compare two FileSpec objects. If "full" is true, then both the
+// directory and the filename must match. If "full" is false, then the
+// directory names for "a" and "b" are only compared if they are both non-
+// empty. This allows a FileSpec object to only contain a filename and it
+// can match FileSpec objects that have matching filenames with different
+// paths.
 //
-// Return -1 if the "a" is less than "b", 0 if "a" is equal to "b"
-// and "1" if "a" is greater than "b".
+// Return -1 if the "a" is less than "b", 0 if "a" is equal to "b" and "1"
+// if "a" is greater than "b".
 //------------------------------------------------------------------
 int FileSpec::Compare(const FileSpec &a, const FileSpec &b, bool full) {
   int result = 0;
@@ -393,12 +392,13 @@
   // case sensitivity of compare
   const bool case_sensitive = a.IsCaseSensitive() || b.IsCaseSensitive();
 
-  // If full is true, then we must compare both the directory and filename.
+  // If full is true, then we must compare both the directory and
+  // filename.
 
   // If full is false, then if either directory is empty, then we match on
-  // the basename only, and if both directories have valid values, we still
-  // do a full compare. This allows for matching when we just have a filename
-  // in one of the FileSpec objects.
+  // the basename only, and if both directories have valid values, we
+  // still do a full compare. This allows for matching when we just have a
+  // filename in one of the FileSpec objects.
 
   if (full || (a.m_directory && b.m_directory)) {
     result = ConstString::Compare(a.m_directory, b.m_directory, case_sensitive);
@@ -511,9 +511,9 @@
 }
 
 //------------------------------------------------------------------
-// Dump the object to the supplied stream. If the object contains
-// a valid directory name, it will be displayed followed by a
-// directory delimiter, and the filename.
+// Dump the object to the supplied stream. If the object contains a valid
+// directory name, it will be displayed followed by a directory delimiter,
+// and the filename.
 //------------------------------------------------------------------
 void FileSpec::Dump(Stream *s) const {
   if (s) {
@@ -555,9 +555,8 @@
         if (Exists())
           return true;
         else {
-          // If FindProgramByName found the file, it returns the directory +
-          // filename in its return results.
-          // We need to separate them.
+          // If FindProgramByName found the file, it returns the directory
+          // + filename in its return results. We need to separate them.
           FileSpec tmp_file(dir_ref.data(), false);
           if (tmp_file.Exists()) {
             m_directory = tmp_file.m_directory;
@@ -575,7 +574,8 @@
   if (m_is_resolved)
     return true; // We have already resolved this path
 
-  // SetFile(...) will set m_is_resolved correctly if it can resolve the path
+  // SetFile(...) will set m_is_resolved correctly if it can resolve the
+  // path
   SetFile(GetPath(false), true);
   return m_is_resolved;
 }
@@ -619,9 +619,8 @@
 const ConstString &FileSpec::GetFilename() const { return m_filename; }
 
 //------------------------------------------------------------------
-// Extract the directory and path into a fixed buffer. This is
-// needed as the directory and path are stored in separate string
-// values.
+// Extract the directory and path into a fixed buffer. This is needed as
+// the directory and path are stored in separate string values.
 //------------------------------------------------------------------
 size_t FileSpec::GetPath(char *path, size_t path_max_len,
                          bool denormalize) const {
@@ -680,9 +679,9 @@
 }
 
 //------------------------------------------------------------------
-// Return the size in bytes that this object takes in memory. This
-// returns the size in bytes of this object, not any shared string
-// values it may refer to.
+// Return the size in bytes that this object takes in memory. This returns
+// the size in bytes of this object, not any shared string values it may
+// refer to.
 //------------------------------------------------------------------
 size_t FileSpec::MemorySize() const {
   return m_filename.MemorySize() + m_directory.MemorySize();
@@ -714,8 +713,8 @@
     if (Result == eEnumerateDirectoryResultQuit)
       return;
     if (Result == eEnumerateDirectoryResultNext) {
-      // Default behavior is to recurse.  Opt out if the callback doesn't want
-      // this behavior.
+      // Default behavior is to recurse.  Opt out if the callback doesn't
+      // want this behavior.
       Iter.no_push();
     }
   }
@@ -941,7 +940,8 @@
     return;
   }
 
-  // Style is either D or empty, either way we need to print the directory.
+  // Style is either D or empty, either way we need to print the
+  // directory.
   if (!dir.empty()) {
     // Directory is stored in normalized form, which might be different
     // than preferred form.  In order to handle this, we need to cut off
Index: source/Utility/JSON.cpp
===================================================================
--- source/Utility/JSON.cpp
+++ source/Utility/JSON.cpp
@@ -372,8 +372,8 @@
             return Token::Status;
           }
         } else {
-          // No exponent, but we need at least one decimal after the decimal
-          // point
+          // No exponent, but we need at least one decimal after the
+          // decimal point
           if (got_frac_digits) {
             return Token::Float;
           } else {
@@ -449,8 +449,7 @@
 
 JSONValue::SP JSONParser::ParseJSONObject() {
   // The "JSONParser::Token::ObjectStart" token should have already been
-  // consumed
-  // by the time this function is called
+  // consumed by the time this function is called
   std::unique_ptr<JSONObject> dict_up(new JSONObject());
 
   std::string value;
@@ -481,8 +480,7 @@
 
 JSONValue::SP JSONParser::ParseJSONArray() {
   // The "JSONParser::Token::ObjectStart" token should have already been
-  // consumed
-  // by the time this function is called
+  // consumed by the time this function is called
   std::unique_ptr<JSONArray> array_up(new JSONArray());
 
   std::string value;
Index: source/Utility/Log.cpp
===================================================================
--- source/Utility/Log.cpp
+++ source/Utility/Log.cpp
@@ -121,9 +121,9 @@
 }
 
 //----------------------------------------------------------------------
-// All logging eventually boils down to this function call. If we have
-// a callback registered, then we call the logging callback. If we have
-// a valid file handle, we also log to the file.
+// All logging eventually boils down to this function call. If we have a
+// callback registered, then we call the logging callback. If we have a
+// valid file handle, we also log to the file.
 //----------------------------------------------------------------------
 void Log::VAPrintf(const char *format, va_list args) {
   llvm::SmallString<64> FinalMessage;
@@ -330,9 +330,9 @@
 }
 
 void Log::DisableLoggingChild() {
-  // Disable logging by clearing out the atomic variable after forking -- if we
-  // forked while another thread held the channel mutex, we would deadlock when
-  // trying to write to the log.
+  // Disable logging by clearing out the atomic variable after forking --
+  // if we forked while another thread held the channel mutex, we would
+  // deadlock when trying to write to the log.
   for (auto &c: *g_channel_map)
     c.second.m_channel.log_ptr.store(nullptr, std::memory_order_relaxed);
 }
Index: source/Utility/RegularExpression.cpp
===================================================================
--- source/Utility/RegularExpression.cpp
+++ source/Utility/RegularExpression.cpp
@@ -14,8 +14,8 @@
 #include <string>
 
 //----------------------------------------------------------------------
-// Enable enhanced mode if it is available. This allows for things like
-// \d for digit, \s for space, and many more, but it isn't available
+// Enable enhanced mode if it is available. This allows for things like \d
+// for digit, \s for space, and many more, but it isn't available
 // everywhere.
 //----------------------------------------------------------------------
 #if defined(REG_ENHANCED)
@@ -31,8 +31,8 @@
 }
 
 //----------------------------------------------------------------------
-// Constructor that compiles "re" using "flags" and stores the
-// resulting compiled regular expression into this object.
+// Constructor that compiles "re" using "flags" and stores the resulting
+// compiled regular expression into this object.
 //----------------------------------------------------------------------
 RegularExpression::RegularExpression(llvm::StringRef str)
     : m_re(), m_comp_err(1), m_preg() {
@@ -55,18 +55,17 @@
 //----------------------------------------------------------------------
 // Destructor
 //
-// Any previously compiled regular expression contained in this
-// object will be freed.
+// Any previously compiled regular expression contained in this object
+// will be freed.
 //----------------------------------------------------------------------
 RegularExpression::~RegularExpression() { Free(); }
 
 //----------------------------------------------------------------------
-// Compile a regular expression using the supplied regular
-// expression text and flags. The compiled regular expression lives
-// in this object so that it can be readily used for regular
-// expression matches. Execute() can be called after the regular
-// expression is compiled. Any previously compiled regular
-// expression contained in this object will be freed.
+// Compile a regular expression using the supplied regular expression text
+// and flags. The compiled regular expression lives in this object so that
+// it can be readily used for regular expression matches. Execute() can be
+// called after the regular expression is compiled. Any previously
+// compiled regular expression contained in this object will be freed.
 //
 // RETURNS
 //  True if the regular expression compiles successfully, false
@@ -75,8 +74,8 @@
 bool RegularExpression::Compile(llvm::StringRef str) {
   Free();
 
-  // regcomp() on darwin does not recognize "" as a valid regular expression, so
-  // we substitute it with an equivalent non-empty one.
+  // regcomp() on darwin does not recognize "" as a valid regular
+  // expression, so we substitute it with an equivalent non-empty one.
   m_re = str.empty() ? "()" : str;
   m_comp_err = ::regcomp(&m_preg, m_re.c_str(), DEFAULT_COMPILE_FLAGS);
   return m_comp_err == 0;
@@ -84,11 +83,11 @@
 
 //----------------------------------------------------------------------
 // Execute a regular expression match using the compiled regular
-// expression that is already in this object against the match
-// string "s". If any parens are used for regular expression
-// matches "match_count" should indicate the number of regmatch_t
-// values that are present in "match_ptr". The regular expression
-// will be executed using the "execute_flags".
+// expression that is already in this object against the match string "s".
+// If any parens are used for regular expression matches "match_count"
+// should indicate the number of regmatch_t values that are present in
+// "match_ptr". The regular expression will be executed using the
+// "execute_flags".
 //---------------------------------------------------------------------
 bool RegularExpression::Execute(llvm::StringRef str, Match *match) const {
   int err = 1;
@@ -159,8 +158,8 @@
 }
 
 //----------------------------------------------------------------------
-// Returns true if the regular expression compiled and is ready
-// for execution.
+// Returns true if the regular expression compiled and is ready for
+// execution.
 //----------------------------------------------------------------------
 bool RegularExpression::IsValid() const { return m_comp_err == 0; }
 
Index: source/Utility/SelectHelper.cpp
===================================================================
--- source/Utility/SelectHelper.cpp
+++ source/Utility/SelectHelper.cpp
@@ -8,9 +8,9 @@
 //===----------------------------------------------------------------------===//
 
 #if defined(__APPLE__)
-// Enable this special support for Apple builds where we can have unlimited
-// select bounds. We tried switching to poll() and kqueue and we were panicing
-// the kernel, so we have to stick with select for now.
+// Enable this special support for Apple builds where we can have
+// unlimited select bounds. We tried switching to poll() and kqueue and we
+// were panicing the kernel, so we have to stick with select for now.
 #define _DARWIN_UNLIMITED_SELECT
 #endif
 
@@ -28,7 +28,8 @@
 
 #include <errno.h>
 #if defined(_WIN32)
-// Define NOMINMAX to avoid macros that conflict with std::min and std::max
+// Define NOMINMAX to avoid macros that conflict with std::min and
+// std::max
 #define NOMINMAX
 #include <winsock2.h>
 #else
@@ -94,8 +95,8 @@
 lldb_private::Status SelectHelper::Select() {
   lldb_private::Status error;
 #ifdef _MSC_VER
-  // On windows FD_SETSIZE limits the number of file descriptors, not their
-  // numeric value.
+  // On windows FD_SETSIZE limits the number of file descriptors, not
+  // their numeric value.
   lldbassert(m_fd_map.size() <= FD_SETSIZE);
   if (m_fd_map.size() > FD_SETSIZE)
     return lldb_private::Status("Too many file descriptors for select()");
@@ -236,8 +237,9 @@
       error.SetErrorString("timed out");
       return error;
     } else {
-      // One or more descriptors were set, update the FDInfo::select_is_set mask
-      // so users can ask the SelectHelper class so clients can call one of:
+      // One or more descriptors were set, update the
+      // FDInfo::select_is_set mask so users can ask the SelectHelper
+      // class so clients can call one of:
 
       for (auto &pair : m_fd_map) {
         const int fd = pair.first;
Index: source/Utility/SharingPtr.cpp
===================================================================
--- source/Utility/SharingPtr.cpp
+++ source/Utility/SharingPtr.cpp
@@ -11,8 +11,8 @@
 
 #if defined(ENABLE_SP_LOGGING)
 
-// If ENABLE_SP_LOGGING is defined, then log all shared pointer assignments
-// and allow them to be queried using a pointer by a call to:
+// If ENABLE_SP_LOGGING is defined, then log all shared pointer
+// assignments and allow them to be queried using a pointer by a call to:
 #include <assert.h>
 #include <execinfo.h>
 
@@ -91,13 +91,13 @@
     }
   }
 }
-// Put dump_sp_refs in the lldb namespace to it gets through our exports lists
-// filter in the LLDB.framework or lldb.so
+// Put dump_sp_refs in the lldb namespace to it gets through our exports
+// lists filter in the LLDB.framework or lldb.so
 namespace lldb {
 
 void dump_sp_refs(void *ptr) {
-  // Use a specially crafted call to "track_sp" which will
-  // dump info on all live shared pointers that reference "ptr"
+  // Use a specially crafted call to "track_sp" which will dump info on
+  // all live shared pointers that reference "ptr"
   track_sp(NULL, ptr, 0);
 }
 }
Index: source/Utility/Status.cpp
===================================================================
--- source/Utility/Status.cpp
+++ source/Utility/Status.cpp
@@ -108,8 +108,8 @@
 
 //----------------------------------------------------------------------
 // Get the error value as a NULL C string. The error string will be
-// fetched and cached on demand. The cached error string value will
-// remain until the error value is changed or cleared.
+// fetched and cached on demand. The cached error string value will remain
+// until the error value is changed or cleared.
 //----------------------------------------------------------------------
 const char *Status::AsCString(const char *default_error_str) const {
   if (Success())
@@ -161,8 +161,8 @@
 ErrorType Status::GetType() const { return m_type; }
 
 //----------------------------------------------------------------------
-// Returns true if this object contains a value that describes an
-// error or otherwise non-success result.
+// Returns true if this object contains a value that describes an error or
+// otherwise non-success result.
 //----------------------------------------------------------------------
 bool Status::Fail() const { return m_code != 0; }
 
@@ -210,8 +210,7 @@
 }
 
 //----------------------------------------------------------------------
-// Update the error value to be "errno" and update the type to
-// be "POSIX".
+// Update the error value to be "errno" and update the type to be "POSIX".
 //----------------------------------------------------------------------
 void Status::SetErrorToErrno() {
   m_code = errno;
@@ -220,8 +219,8 @@
 }
 
 //----------------------------------------------------------------------
-// Update the error value to be LLDB_GENERIC_ERROR and update the type
-// to be "Generic".
+// Update the error value to be LLDB_GENERIC_ERROR and update the type to
+// be "Generic".
 //----------------------------------------------------------------------
 void Status::SetErrorToGenericError() {
   m_code = LLDB_GENERIC_ERROR;
@@ -230,10 +229,10 @@
 }
 
 //----------------------------------------------------------------------
-// Set accessor for the error string value for a specific error.
-// This allows any string to be supplied as an error explanation.
-// The error string value will remain until the error value is
-// cleared or a new error value/type is assigned.
+// Set accessor for the error string value for a specific error. This
+// allows any string to be supplied as an error explanation. The error
+// string value will remain until the error value is cleared or a new
+// error value/type is assigned.
 //----------------------------------------------------------------------
 void Status::SetErrorString(llvm::StringRef err_str) {
   if (!err_str.empty()) {
@@ -266,8 +265,8 @@
 
 int Status::SetErrorStringWithVarArg(const char *format, va_list args) {
   if (format != nullptr && format[0]) {
-    // If we have an error string, we should always at least have
-    // an error set to a generic value.
+    // If we have an error string, we should always at least have an error
+    // set to a generic value.
     if (Success())
       SetErrorToGenericError();
 
Index: source/Utility/Stream.cpp
===================================================================
--- source/Utility/Stream.cpp
+++ source/Utility/Stream.cpp
@@ -41,14 +41,14 @@
 }
 
 //------------------------------------------------------------------
-// Put an offset "uval" out to the stream using the printf format
-// in "format".
+// Put an offset "uval" out to the stream using the printf format in
+// "format".
 //------------------------------------------------------------------
 void Stream::Offset(uint32_t uval, const char *format) { Printf(format, uval); }
 
 //------------------------------------------------------------------
-// Put an SLEB128 "uval" out to the stream using the printf format
-// in "format".
+// Put an SLEB128 "uval" out to the stream using the printf format in
+// "format".
 //------------------------------------------------------------------
 size_t Stream::PutSLEB128(int64_t sval) {
   size_t bytes_written = 0;
@@ -73,8 +73,8 @@
 }
 
 //------------------------------------------------------------------
-// Put an ULEB128 "uval" out to the stream using the printf format
-// in "format".
+// Put an ULEB128 "uval" out to the stream using the printf format in
+// "format".
 //------------------------------------------------------------------
 size_t Stream::PutULEB128(uint64_t uval) {
   size_t bytes_written = 0;
@@ -109,16 +109,16 @@
 }
 
 //------------------------------------------------------------------
-// Print a double quoted NULL terminated C string to the stream
-// using the printf format in "format".
+// Print a double quoted NULL terminated C string to the stream using the
+// printf format in "format".
 //------------------------------------------------------------------
 void Stream::QuotedCString(const char *cstr, const char *format) {
   Printf(format, cstr);
 }
 
 //------------------------------------------------------------------
-// Put an address "addr" out to the stream with optional prefix
-// and suffix strings.
+// Put an address "addr" out to the stream with optional prefix and suffix
+// strings.
 //------------------------------------------------------------------
 void Stream::Address(uint64_t addr, uint32_t addr_size, const char *prefix,
                      const char *suffix) {
@@ -132,8 +132,8 @@
 }
 
 //------------------------------------------------------------------
-// Put an address range out to the stream with optional prefix
-// and suffix strings.
+// Put an address range out to the stream with optional prefix and suffix
+// strings.
 //------------------------------------------------------------------
 void Stream::AddressRange(uint64_t lo_addr, uint64_t hi_addr,
                           uint32_t addr_size, const char *prefix,
@@ -179,8 +179,8 @@
 size_t Stream::EOL() { return PutChar('\n'); }
 
 //------------------------------------------------------------------
-// Indent the current line using the current indentation level and
-// print an optional string following the indentation spaces.
+// Indent the current line using the current indentation level and print
+// an optional string following the indentation spaces.
 //------------------------------------------------------------------
 size_t Stream::Indent(const char *s) {
   return Printf("%*.*s%s", m_indent_level, m_indent_level, "", s ? s : "");
Index: source/Utility/StringExtractor.cpp
===================================================================
--- source/Utility/StringExtractor.cpp
+++ source/Utility/StringExtractor.cpp
@@ -74,9 +74,8 @@
 }
 
 //----------------------------------------------------------------------
-// If a pair of valid hex digits exist at the head of the
-// StringExtractor they are decoded into an unsigned byte and returned
-// by this function
+// If a pair of valid hex digits exist at the head of the StringExtractor
+// they are decoded into an unsigned byte and returned by this function
 //
 // If there is not a pair of valid hex digits at the head of the
 // StringExtractor, it is left unchanged and -1 is returned
@@ -100,8 +99,8 @@
 // string, or return fail_value on failure
 //----------------------------------------------------------------------
 uint8_t StringExtractor::GetHexU8(uint8_t fail_value, bool set_eof_on_fail) {
-  // On success, fail_value will be overwritten with the next
-  // character in the stream
+  // On success, fail_value will be overwritten with the next character in
+  // the stream
   GetHexU8Ex(fail_value, set_eof_on_fail);
   return fail_value;
 }
@@ -307,8 +306,8 @@
 }
 
 //----------------------------------------------------------------------
-// Decodes all valid hex encoded bytes at the head of the
-// StringExtractor, limited by dst_len.
+// Decodes all valid hex encoded bytes at the head of the StringExtractor,
+// limited by dst_len.
 //
 // Returns the number of bytes successfully decoded
 //----------------------------------------------------------------------
@@ -325,8 +324,8 @@
   return bytes_extracted;
 }
 
-// Consume ASCII hex nibble character pairs until we have decoded byte_size
-// bytes of data.
+// Consume ASCII hex nibble character pairs until we have decoded
+// byte_size bytes of data.
 
 uint64_t StringExtractor::GetHexWithFixedSize(uint32_t byte_size,
                                               bool little_endian,
@@ -391,8 +390,8 @@
 bool StringExtractor::GetNameColonValue(llvm::StringRef &name,
                                         llvm::StringRef &value) {
   // Read something in the form of NNNN:VVVV; where NNNN is any character
-  // that is not a colon, followed by a ':' character, then a value (one or
-  // more ';' chars), followed by a ';'
+  // that is not a colon, followed by a ':' character, then a value (one
+  // or more ';' chars), followed by a ';'
   if (m_index >= m_packet.size())
     return fail();
 
Index: source/Utility/StringExtractorGDBRemote.cpp
===================================================================
--- source/Utility/StringExtractorGDBRemote.cpp
+++ source/Utility/StringExtractorGDBRemote.cpp
@@ -482,10 +482,9 @@
 
 size_t StringExtractorGDBRemote::GetEscapedBinaryData(std::string &str) {
   // Just get the data bytes in the string as
-  // GDBRemoteCommunication::CheckForPacket()
-  // already removes any 0x7d escaped characters. If any 0x7d characters are
-  // left in
-  // the packet, then they are supposed to be there...
+  // GDBRemoteCommunication::CheckForPacket() already removes any 0x7d
+  // escaped characters. If any 0x7d characters are left in the packet,
+  // then they are supposed to be there...
   str.clear();
   const size_t bytes_left = GetBytesLeft();
   if (bytes_left > 0) {
@@ -525,11 +524,11 @@
     break;
 
   case StringExtractorGDBRemote::eResponse:
-    // JSON that is returned in from JSON query packets is currently always
-    // either a dictionary which starts with a '{', or an array which
-    // starts with a '['. This is a quick validator to just make sure the
-    // response could be valid JSON without having to validate all of the
-    // JSON content.
+    // JSON that is returned in from JSON query packets is currently
+    // always either a dictionary which starts with a '{', or an array
+    // which starts with a '['. This is a quick validator to just make
+    // sure the response could be valid JSON without having to validate
+    // all of the JSON content.
     switch (response.GetStringRef()[0]) {
     case '{':
       return true;
Index: source/Utility/StructuredData.cpp
===================================================================
--- source/Utility/StructuredData.cpp
+++ source/Utility/StructuredData.cpp
@@ -85,8 +85,7 @@
 
 static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser) {
   // The "JSONParser::Token::ObjectStart" token should have already been
-  // consumed
-  // by the time this function is called
+  // consumed by the time this function is called
   auto array_up = llvm::make_unique<StructuredData::Array>();
 
   std::string value;
@@ -162,8 +161,8 @@
     std::string key = match.first.str();
     ObjectSP value = this->GetAsDictionary()->GetValueForKey(key);
     if (value.get()) {
-      // Do we have additional words to descend?  If not, return the
-      // value we're at right now.
+      // Do we have additional words to descend?  If not, return the value
+      // we're at right now.
       if (match.second.empty()) {
         return value;
       } else {
Index: source/Utility/UUID.cpp
===================================================================
--- source/Utility/UUID.cpp
+++ source/Utility/UUID.cpp
@@ -133,8 +133,8 @@
       // Skip both hex digits
       p = p.drop_front(2);
 
-      // Increment the byte that we are decoding within the UUID value
-      // and break out if we are done
+      // Increment the byte that we are decoding within the UUID value and
+      // break out if we are done
       if (++uuid_byte_idx == num_uuid_bytes)
         break;
     } else if (p.front() == '-') {
@@ -163,8 +163,8 @@
   llvm::StringRef rest =
       UUID::DecodeUUIDBytesFromString(p, m_uuid, bytes_decoded, num_uuid_bytes);
 
-  // If we successfully decoded a UUID, return the amount of characters that
-  // were consumed
+  // If we successfully decoded a UUID, return the amount of characters
+  // that were consumed
   if (bytes_decoded == num_uuid_bytes) {
     m_num_uuid_bytes = num_uuid_bytes;
     return str.size() - rest.size();
Index: source/Utility/VASprintf.cpp
===================================================================
--- source/Utility/VASprintf.cpp
+++ source/Utility/VASprintf.cpp
@@ -36,8 +36,8 @@
   }
 
   if (size_t(length) >= buf.size()) {
-    // The error formatted string didn't fit into our buffer, resize it
-    // to the exact needed size, and retry
+    // The error formatted string didn't fit into our buffer, resize it to
+    // the exact needed size, and retry
     buf.resize(length + 1);
     length = ::vsnprintf(buf.data(), buf.size(), fmt, copy_args);
     if (length < 0) {
Index: source/lldb.cpp
===================================================================
--- source/lldb.cpp
+++ source/lldb.cpp
@@ -42,8 +42,8 @@
 #define EXPAND_AND_QUOTE(str) QUOTE(str)
 
 const char *lldb_private::GetVersion() {
-  // On platforms other than Darwin, report a version number in the same style
-  // as the clang tool.
+  // On platforms other than Darwin, report a version number in the same
+  // style as the clang tool.
   static std::string g_version_str;
   if (g_version_str.empty()) {
     g_version_str += "lldb version ";