Reflow paragraphs in comments.

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

FYI, the script I used was:

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

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

          continue

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

      out.write(line)

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

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

llvm-svn: 331197

1 files changed, 72 insertions, 80 deletions

diff --git a/lldb/source/Target/StackFrame.cpp b/lldb/source/Target/StackFrame.cpp
index dd44eac8e50..d6fafffbee0 100644
--- a/lldb/source/Target/StackFrame.cpp
+++ b/lldb/source/Target/StackFrame.cpp
@@ -60,8 +60,8 @@ StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
       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.
+  // 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,17 +136,17 @@ StackFrame::~StackFrame() = default;
 
 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()) {
-      // We already have a symbol context scope, we just don't have our
-      // flag bit set.
+      // We already have a symbol context scope, we just don't have our flag
+      // bit set.
       m_flags.Set(RESOLVED_FRAME_ID_SYMBOL_SCOPE);
     } else {
-      // Calculate the frame block and use this for the stack ID symbol
-      // context scope if we have one.
+      // Calculate the frame block and use this for the stack ID symbol context
+      // scope if we have one.
       SymbolContextScope *scope = GetFrameBlock();
       if (scope == nullptr) {
         // We don't have a block, so use the symbol
@@ -247,13 +247,13 @@ Block *StackFrame::GetFrameBlock() {
   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
-      // with so we want to use the top most function block.
+      // This block is not contained within any inlined function blocks with so
+      // we want to use the top most function block.
       return &m_sc.function->GetBlock(false);
     }
   }
@@ -263,8 +263,8 @@ Block *StackFrame::GetFrameBlock() {
 //----------------------------------------------------------------------
 // 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,15 +279,15 @@ const SymbolContext &StackFrame::GetSymbolContext(uint32_t resolve_scope) {
         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
-    // contain the module to which it belongs
+    // 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();
 
-    // If this is not frame zero, then we need to subtract 1 from the PC
-    // value when doing address lookups since the PC will be on the
-    // instruction following the function call instruction...
+    // If this is not frame zero, then we need to subtract 1 from the PC value
+    // when doing address lookups since the PC will be on the instruction
+    // following the function call instruction...
 
     Address lookup_addr(GetFrameCodeAddress());
     if (m_frame_index > 0 && lookup_addr.IsValid()) {
@@ -296,10 +296,9 @@ const SymbolContext &StackFrame::GetSymbolContext(uint32_t resolve_scope) {
         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());
@@ -315,9 +314,9 @@ const SymbolContext &StackFrame::GetSymbolContext(uint32_t resolve_scope) {
     }
 
     if (m_sc.module_sp) {
-      // We have something in our stack frame symbol context, lets check
-      // if we haven't already tried to lookup one of those things. If we
-      // haven't then we will do the query.
+      // We have something in our stack frame symbol context, lets check if we
+      // haven't already tried to lookup one of those things. If we haven't
+      // then we will do the query.
 
       uint32_t actual_resolve_scope = 0;
 
@@ -367,17 +366,16 @@ const SymbolContext &StackFrame::GetSymbolContext(uint32_t resolve_scope) {
       }
 
       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
+        // 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
         if ((resolved & eSymbolContextCompUnit) && m_sc.comp_unit == nullptr)
           m_sc.comp_unit = sc.comp_unit;
         if ((resolved & eSymbolContextFunction) && m_sc.function == nullptr)
@@ -404,9 +402,9 @@ const SymbolContext &StackFrame::GetSymbolContext(uint32_t resolve_scope) {
 
     // 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
+    // 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);
   }
 
@@ -546,8 +544,8 @@ ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
   }
 
   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;
@@ -622,9 +620,8 @@ ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
             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();
         }
       }
@@ -659,15 +656,14 @@ ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
       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 +693,8 @@ ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
           // 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 +729,8 @@ ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
     } 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\"",
@@ -790,11 +784,10 @@ ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
           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()) {
@@ -828,8 +821,8 @@ ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
 
             return ValueObjectSP();
           } else if (is_objc_pointer) {
-            // dereferencing ObjC variables is not valid.. so let's try
-            // and recur to synthetic children
+            // dereferencing ObjC variables is not valid.. so let's try and
+            // recur to synthetic children
             ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
             if (!synthetic                 /* no synthetic */
                 || synthetic == valobj_sp) /* synthetic is the same as
@@ -874,9 +867,8 @@ ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
           }
         } 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...
+          // Pass false to dynamic_value here so we can tell the 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 =
@@ -976,8 +968,8 @@ ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
       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
+        // 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 +983,10 @@ ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
         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()) {
@@ -1091,8 +1083,8 @@ bool StackFrame::GetFrameBaseValue(Scalar &frame_base, Status *error_ptr) {
       if (m_sc.function->GetFrameBaseExpression().Evaluate(
               &exe_ctx, nullptr, loclist_base_addr, nullptr, nullptr,
               expr_value, &m_frame_base_error) == false) {
-        // We should really have an error if evaluate returns, but in case
-        // we don't, lets set the error to something at least.
+        // We should really have an error if evaluate returns, but in case we
+        // don't, lets set the error to something at least.
         if (m_frame_base_error.Success())
           m_frame_base_error.SetErrorString(
               "Evaluation of the frame base expression failed.");
@@ -1420,8 +1412,8 @@ ValueObjectSP GetValueForDereferincingOffset(StackFrame &frame,
                                              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 +1478,8 @@ lldb::ValueObjectSP DoGuessValueAt(StackFrame &frame, ConstString reg,
   //
   // 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
@@ -1533,9 +1525,9 @@ lldb::ValueObjectSP DoGuessValueAt(StackFrame &frame, ConstString reg,
 
   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);