Handlify AddDependentCode(), AddDependentCompilationInfo() and AddDependentIC().

src/hydrogen.cc

 // Copyright 2013 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 4907 matching lines @@
 
       if (type == kUseCell &&
           current_info()->global_object()->IsAccessCheckNeeded()) {
         type = kUseGeneric;
       }
 
       if (type == kUseCell) {
         Handle<GlobalObject> global(current_info()->global_object());
         Handle<PropertyCell> cell(global->GetPropertyCell(&lookup));
         if (cell->type()->IsConstant()) {
-          cell->AddDependentCompilationInfo(top_info());
+          PropertyCell::AddDependentCompilationInfo(cell, top_info());
           Handle<Object> constant_object = cell->type()->AsConstant();
           if (constant_object->IsConsString()) {
             constant_object =
                 String::Flatten(Handle<String>::cast(constant_object));
           }
           HConstant* constant = New<HConstant>(constant_object);
           return ast_context()->ReturnInstruction(constant, expr->id());
         } else {
           HLoadGlobalCell* instr =
               New<HLoadGlobalCell>(cell, lookup.GetPropertyDetails());
@@ skipping 606 matching lines @@
 }
 
 
 void HOptimizedGraphBuilder::PropertyAccessInfo::LoadFieldMap(Handle<Map> map) {
   // Figure out the field type from the accessor map.
   HeapType* field_type = lookup_.GetFieldTypeFromMap(*map);
   if (field_type->IsClass()) {
     Handle<Map> field_map = field_type->AsClass();
     if (field_map->is_stable()) {
       field_map_ = field_map;
-      field_map_->AddDependentCompilationInfo(
-          DependentCode::kPrototypeCheckGroup, top_info());
+      Map::AddDependentCompilationInfo(
+          field_map_, DependentCode::kPrototypeCheckGroup, top_info());
 
       // Add dependency on the map that introduced the field.
-      lookup_.GetFieldOwnerFromMap(*map)->AddDependentCompilationInfo(
+      Map::AddDependentCompilationInfo(
+          handle(lookup_.GetFieldOwnerFromMap(*map), isolate()),
           DependentCode::kFieldTypeGroup, top_info());
     }
   }
 }
 
 
 bool HOptimizedGraphBuilder::PropertyAccessInfo::LookupInPrototypes() {
   Handle<Map> map = this->map();
 
   while (map->prototype()->IsJSObject()) {
@@ skipping 1251 matching lines @@
 
   BuildLoad(expr, expr->id());
 }
 
 
 HInstruction* HGraphBuilder::BuildConstantMapCheck(Handle<JSObject> constant,
                                                    CompilationInfo* info) {
   HConstant* constant_value = New<HConstant>(constant);
 
   if (constant->map()->CanOmitMapChecks()) {
-    constant->map()->AddDependentCompilationInfo(
+    Map::AddDependentCompilationInfo(
+        handle(constant->map(), info->isolate()),

[Igor Sheludko, 2014/04/15 08:58:35]

Suggestion: below we are also wrapping the map to a handle. What if we do that
only once?

[Benedikt Meurer, 2014/04/15 10:15:02]

Done.

         DependentCode::kPrototypeCheckGroup, info);
     return constant_value;
   }
 
   AddInstruction(constant_value);
   HCheckMaps* check =
       Add<HCheckMaps>(constant_value, handle(constant->map()), info);
   check->ClearDependsOnFlag(kElementsKind);
   return check;
 }
@@ skipping 4758 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal