[tubofan] Greedy: groupper -> grouper.

src/compiler/greedy-allocator.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/greedy-allocator.h"
 #include "src/compiler/register-allocator.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
@@ skipping 158 matching lines @@
 
       int reg_nr = fixed_range->assigned_register();
       EnsureValidRangeWeight(fixed_range);
       AllocateRegisterToRange(reg_nr, fixed_range);
     }
   }
 }
 
 
 void GreedyAllocator::GroupLiveRanges() {
-  CoalescedLiveRanges groupper(local_zone());
+  CoalescedLiveRanges grouper(local_zone());
   for (TopLevelLiveRange* range : data()->live_ranges()) {
-    groupper.clear();
+    grouper.clear();
     // Skip splinters, because we do not want to optimize for them, and moves
     // due to assigning them to different registers occur in deferred blocks.
     if (!CanProcessRange(range) || range->IsSplinter() || !range->is_phi()) {
       continue;
     }
 
     // A phi can't be a memory operand, so it couldn't have been split.
     DCHECK(!range->spilled());
 
     // Maybe this phi range is itself an input to another phi which was already
     // processed.
     LiveRangeGroup* latest_grp = range->group() != nullptr
                                      ? range->group()
                                      : new (local_zone())
                                            LiveRangeGroup(local_zone());
 
-    // Populate the groupper.
+    // Populate the grouper.
     if (range->group() == nullptr) {
-      groupper.AllocateRange(range);
+      grouper.AllocateRange(range);
     } else {
       for (LiveRange* member : range->group()->ranges()) {
-        groupper.AllocateRange(member);
+        grouper.AllocateRange(member);
       }
     }
     for (int j : data()->GetPhiMapValueFor(range)->phi()->operands()) {
       // skip output also in input, which may happen for loops.
       if (j == range->vreg()) continue;
 
       TopLevelLiveRange* other_top = data()->live_ranges()[j];
 
       if (other_top->IsSplinter()) continue;
       // If the other was a memory operand, it might have been split.
       // So get the unsplit part.
       LiveRange* other =
           other_top->next() == nullptr ? other_top : other_top->next();
 
       if (other->spilled()) continue;
 
       LiveRangeGroup* other_group = other->group();
       if (other_group != nullptr) {
         bool can_merge = true;
         for (LiveRange* member : other_group->ranges()) {
-          if (groupper.GetConflicts(member).Current() != nullptr) {
+          if (grouper.GetConflicts(member).Current() != nullptr) {
             can_merge = false;
             break;
           }
         }
         // If each member doesn't conflict with the current group, then since
         // the members don't conflict with eachother either, we can merge them.
         if (can_merge) {
           latest_grp->ranges().insert(latest_grp->ranges().end(),
                                       other_group->ranges().begin(),
                                       other_group->ranges().end());
           for (LiveRange* member : other_group->ranges()) {
-            groupper.AllocateRange(member);
+            grouper.AllocateRange(member);
             member->set_group(latest_grp);
           }
           // Clear the other range, so we avoid scheduling it.
           other_group->ranges().clear();
         }
-      } else if (groupper.GetConflicts(other).Current() == nullptr) {
-        groupper.AllocateRange(other);
+      } else if (grouper.GetConflicts(other).Current() == nullptr) {
+        grouper.AllocateRange(other);
         latest_grp->ranges().push_back(other);
         other->set_group(latest_grp);
       }
     }
 
     if (latest_grp->ranges().size() > 0 && range->group() == nullptr) {
       latest_grp->ranges().push_back(range);
       DCHECK(latest_grp->ranges().size() > 1);
       groups().push_back(latest_grp);
       range->set_group(latest_grp);
@@ skipping 405 matching lines @@
     scheduler().Schedule(range);
     return;
   }
   SpillRangeAsLastResort(range);
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8