[Isolates] Merge crankshaft (r5922 from bleeding_edge).

src/profile-generator.cc

 // Copyright 2010 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 587 matching lines @@
   } else {
     return NULL;
   }
   List<CpuProfile*>* unabridged_list =
       profiles_by_token_[TokenToIndex(TokenEnumerator::kNoSecurityToken)];
   if (security_token_id == TokenEnumerator::kNoSecurityToken) {
     return unabridged_list->at(index);
   }
   List<CpuProfile*>* list = GetProfilesList(security_token_id);
   if (list->at(index) == NULL) {
-      list->at(index) =
-          unabridged_list->at(index)->FilteredClone(security_token_id);
+    (*list)[index] =
+        unabridged_list->at(index)->FilteredClone(security_token_id);
   }
   return list->at(index);
 }
 
 
 bool CpuProfilesCollection::IsLastProfile(const char* title) {
   // Called from VM thread, and only it can mutate the list,
   // so no locking is needed here.
   if (current_profiles_.length() != 1) return false;
   return StrLength(title) == 0
@@ skipping 28 matching lines @@
 List<CpuProfile*>* CpuProfilesCollection::Profiles(int security_token_id) {
   List<CpuProfile*>* unabridged_list =
       profiles_by_token_[TokenToIndex(TokenEnumerator::kNoSecurityToken)];
   if (security_token_id == TokenEnumerator::kNoSecurityToken) {
     return unabridged_list;
   }
   List<CpuProfile*>* list = GetProfilesList(security_token_id);
   const int current_count = unabridged_list->length();
   for (int i = 0; i < current_count; ++i) {
     if (list->at(i) == NULL) {
-      list->at(i) = unabridged_list->at(i)->FilteredClone(security_token_id);
+      (*list)[i] = unabridged_list->at(i)->FilteredClone(security_token_id);
     }
   }
   return list;
 }
 
 
 CodeEntry* CpuProfilesCollection::NewCodeEntry(Logger::LogEventsAndTags tag,
                                                String* name,
                                                String* resource_name,
                                                int line_number) {
@@ skipping 731 matching lines @@
       if (children[i].type() == HeapGraphEdge::kShortcut) continue;
       HeapEntry* child = children[i].to();
       if (!child->painted_reachable()) {
         nodes_to_visit.Add(child);
         child->paint_reachable();
         has_new_edges = true;
       }
     }
     if (!has_new_edges) {
       entry->set_ordered_index(current_entry);
-      entries->at(current_entry++) = entry;
+      (*entries)[current_entry++] = entry;
       nodes_to_visit.RemoveLast();
     }
   }
   entries->Truncate(current_entry);
 }
 
 
 static int Intersect(int i1, int i2, const Vector<HeapEntry*>& dominators) {
   int finger1 = i1, finger2 = i2;
   while (finger1 != finger2) {
     while (finger1 < finger2) finger1 = dominators[finger1]->ordered_index();
     while (finger2 < finger1) finger2 = dominators[finger2]->ordered_index();
   }
   return finger1;
 }
 
 // The algorithm is based on the article:
 // K. Cooper, T. Harvey and K. Kennedy "A Simple, Fast Dominance Algorithm"
 // Softw. Pract. Exper. 4 (2001), pp. 1–10.
 void HeapSnapshot::BuildDominatorTree(const Vector<HeapEntry*>& entries,
                                       Vector<HeapEntry*>* dominators) {
   if (entries.length() == 0) return;
   const int root_index = entries.length() - 1;
-  for (int i = 0; i < root_index; ++i) dominators->at(i) = NULL;
-  dominators->at(root_index) = entries[root_index];
+  for (int i = 0; i < root_index; ++i) (*dominators)[i] = NULL;
+  (*dominators)[root_index] = entries[root_index];
   bool changed = true;
   while (changed) {
     changed = false;
     for (int i = root_index - 1; i >= 0; --i) {
       HeapEntry* new_idom = NULL;
       Vector<HeapGraphEdge*> rets = entries[i]->retainers();
       int j = 0;
       for (; j < rets.length(); ++j) {
         if (rets[j]->type() == HeapGraphEdge::kShortcut) continue;
         HeapEntry* ret = rets[j]->From();
         if (dominators->at(ret->ordered_index()) != NULL) {
           new_idom = ret;
           break;
         }
       }
       for (++j; j < rets.length(); ++j) {
         if (rets[j]->type() == HeapGraphEdge::kShortcut) continue;
         HeapEntry* ret = rets[j]->From();
         if (dominators->at(ret->ordered_index()) != NULL) {
           new_idom = entries[Intersect(ret->ordered_index(),
                                        new_idom->ordered_index(),
                                        *dominators)];
         }
       }
       if (new_idom != NULL && dominators->at(i) != new_idom) {
-        dominators->at(i) = new_idom;
+        (*dominators)[i] = new_idom;
         changed = true;
       }
     }
   }
 }
 
 
 void HeapSnapshot::SetDominatorsToSelf() {
   for (int i = 0; i < entries_.length(); ++i) {
     HeapEntry* entry = entries_[i];
@@ skipping 1326 matching lines @@
 
 
 String* GetConstructorNameForHeapProfile(JSObject* object) {
   if (object->IsJSFunction()) return HEAP->closure_symbol();
   return object->constructor_name();
 }
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_LOGGING_AND_PROFILING