Fix asterisk spacing.

src/mark-compact.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 453 matching lines @@
   // Mark the Object* fields of the Map.
   // Since the descriptor array has been marked already, it is fine
   // that one of these fields contains a pointer to it.
   MarkingVisitor visitor;  // Has no state or contents.
   visitor.VisitPointers(HeapObject::RawField(map, Map::kPrototypeOffset),
                         HeapObject::RawField(map, Map::kSize));
 }
 
 
 void MarkCompactCollector::MarkDescriptorArray(
-    DescriptorArray *descriptors) {
+    DescriptorArray* descriptors) {
   if (descriptors->IsMarked()) return;
   // Empty descriptor array is marked as a root before any maps are marked.
   ASSERT(descriptors != Heap::empty_descriptor_array());
   SetMark(descriptors);
 
   FixedArray* contents = reinterpret_cast<FixedArray*>(
       descriptors->get(DescriptorArray::kContentArrayIndex));
   ASSERT(contents->IsHeapObject());
   ASSERT(!contents->IsMarked());
   ASSERT(contents->IsFixedArray());
@@ skipping 379 matching lines @@
     while (SafeIsMap(current)) {
       current = reinterpret_cast<Map*>(current->prototype());
       ASSERT(current->IsHeapObject());
     }
     Object* real_prototype = current;
 
     // Follow back pointers, setting them to prototype,
     // clearing map transitions when necessary.
     current = map;
     bool on_dead_path = !current->IsMarked();
-    Object *next;
+    Object* next;
     while (SafeIsMap(current)) {
       next = current->prototype();
       // There should never be a dead map above a live map.
       ASSERT(on_dead_path || current->IsMarked());
 
       // A live map above a dead map indicates a dead transition.
       // This test will always be false on the first iteration.
       if (on_dead_path && current->IsMarked()) {
         on_dead_path = false;
         current->ClearNonLiveTransitions(real_prototype);
@@ skipping 909 matching lines @@
 
 void MarkCompactCollector::RebuildRSets() {
 #ifdef DEBUG
   ASSERT(state_ == RELOCATE_OBJECTS);
   state_ = REBUILD_RSETS;
 #endif
   Heap::RebuildRSets();
 }
 
 } }  // namespace v8::internal