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

3 files changed, 95 insertions, 120 deletions

diff --git a/lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp b/lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp
index f8aca4d1283..a8872533981 100644
--- a/lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp
+++ b/lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp
@@ -58,8 +58,8 @@ bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly(
   if (range.GetByteSize() > 0 && range.GetBaseAddress().IsValid() &&
       m_inst_emulator_ap.get()) {
 
-    // The instruction emulation subclass setup the unwind plan for the
-    // first instruction.
+    // The instruction emulation subclass setup the unwind plan for the first
+    // instruction.
     m_inst_emulator_ap->CreateFunctionEntryUnwind(unwind_plan);
 
     // CreateFunctionEntryUnwind should have created the first row. If it
@@ -90,9 +90,9 @@ bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly(
       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,14 +105,12 @@ bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly(
         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;
 
@@ -128,15 +126,14 @@ bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly(
         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.
+        // 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 +157,11 @@ bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly(
                    "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 +177,9 @@ bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly(
               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 +187,8 @@ bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly(
               }
 
               // 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 =
@@ -230,8 +225,7 @@ bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly(
                 eEmulateInstructionOptionIgnoreConditions);
 
             // If the current instruction is a branch forward then save the
-            // current CFI information
-            // for the offset where we are branching.
+            // 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 +241,8 @@ bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly(
             // 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 +
diff --git a/lldb/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp b/lldb/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp
index b8dcd99a53e..327d0b0e4f7 100644
--- a/lldb/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp
+++ b/lldb/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp
@@ -86,12 +86,10 @@ bool UnwindAssembly_x86::AugmentUnwindPlanFromCallSite(
                            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
-  // unwinder code, fall back to assembly parsing instead.
+  // 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() !=
           UnwindPlan::Row::CFAValue::isRegisterPlusOffset ||
@@ -110,14 +108,13 @@ bool UnwindAssembly_x86::AugmentUnwindPlanFromCallSite(
     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".
@@ -128,8 +125,8 @@ bool UnwindAssembly_x86::AugmentUnwindPlanFromCallSite(
             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(
@@ -139,12 +136,10 @@ bool UnwindAssembly_x86::AugmentUnwindPlanFromCallSite(
             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"?
+          // 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.
+          // and we don't need to modify it at all.
 
           if (first_row_pc_loc.GetOffset() == -wordsize) {
             do_augment_unwindplan = false;
diff --git a/lldb/source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp b/lldb/source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp
index aa15063ac0d..10a56980594 100644
--- a/lldb/source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp
+++ b/lldb/source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp
@@ -246,8 +246,7 @@ void x86AssemblyInspectionEngine::Initialize(
 }
 
 // This function expects an x86 native register number (i.e. the bits stripped
-// out of the
-// actual instruction), not an lldb register number.
+// out of the actual instruction), not an lldb register number.
 //
 // FIXME: This is ABI dependent, it shouldn't be hardcoded here.
 
@@ -321,15 +320,14 @@ bool x86AssemblyInspectionEngine::push_imm_pattern_p() {
 
 // 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 @@ bool x86AssemblyInspectionEngine::push_extended_pattern_p() {
     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 @@ bool x86AssemblyInspectionEngine::push_reg_p(int &regno) {
   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 @@ bool x86AssemblyInspectionEngine::call_next_insn_pattern_p() {
          (*(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 @@ bool x86AssemblyInspectionEngine::mov_reg_to_local_stack_frame_p(
     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++;
@@ -671,18 +668,16 @@ bool x86AssemblyInspectionEngine::GetNonCallSiteUnwindPlanFromAssembly(
   *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
-  // (i386_register_numbers, x86_64_register_numbers).
+  // 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
@@ -723,9 +718,8 @@ bool x86AssemblyInspectionEngine::GetNonCallSiteUnwindPlanFromAssembly(
     }
 
     // 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 --
+    // 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()) {
@@ -733,9 +727,9 @@ bool x86AssemblyInspectionEngine::GetNonCallSiteUnwindPlanFromAssembly(
 
     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;
@@ -772,8 +766,7 @@ bool x86AssemblyInspectionEngine::GetNonCallSiteUnwindPlanFromAssembly(
       }
 
       // 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.
+      // 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 +783,13 @@ bool x86AssemblyInspectionEngine::GetNonCallSiteUnwindPlanFromAssembly(
       }
     }
 
-    // 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.
+      // 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 +815,11 @@ bool x86AssemblyInspectionEngine::GetNonCallSiteUnwindPlanFromAssembly(
 
       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 +871,8 @@ bool x86AssemblyInspectionEngine::GetNonCallSiteUnwindPlanFromAssembly(
     }
 
     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();
@@ -960,16 +952,15 @@ bool x86AssemblyInspectionEngine::AugmentUnwindPlanFromCallSite(
   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 +985,9 @@ bool x86AssemblyInspectionEngine::AugmentUnwindPlanFromCallSite(
   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 +1004,7 @@ bool x86AssemblyInspectionEngine::AugmentUnwindPlanFromCallSite(
     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 +1032,8 @@ bool x86AssemblyInspectionEngine::AugmentUnwindPlanFromCallSite(
     }
 
     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 +1073,9 @@ bool x86AssemblyInspectionEngine::AugmentUnwindPlanFromCallSite(
       }
       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);