Add OptimizedCodeEntry as a new heap object type. An optimized code entry represents an association…

src/heap.cc

 // Copyright 2012 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 2806 matching lines @@
   native_context_map->set_dictionary_map(true);
   native_context_map->set_visitor_id(StaticVisitorBase::kVisitNativeContext);
   set_native_context_map(native_context_map);
 
   { MaybeObject* maybe_obj = AllocateMap(SHARED_FUNCTION_INFO_TYPE,
                                          SharedFunctionInfo::kAlignedSize);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_shared_function_info_map(Map::cast(obj));
 
+  { MaybeObject* maybe_obj = AllocateMap(OPTIMIZED_CODE_ENTRY_TYPE,
+                                         OptimizedCodeEntry::kAlignedSize);
+    if (!maybe_obj->ToObject(&obj)) return false;
+  }
+  set_optimized_code_entry_map(Map::cast(obj));
+
   { MaybeObject* maybe_obj = AllocateMap(JS_MESSAGE_OBJECT_TYPE,
                                          JSMessageObject::kSize);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_message_object_map(Map::cast(obj));
 
   Map* external_map;
   { MaybeObject* maybe_obj =
         AllocateMap(JS_OBJECT_TYPE, JSObject::kHeaderSize + kPointerSize);
     if (!maybe_obj->To(&external_map)) return false;
@@ skipping 807 matching lines @@
   share->set_end_position(0);
   share->set_function_token_position(0);
   // All compiler hints default to false or 0.
   share->set_compiler_hints(0);
   share->set_opt_count(0);
 
   return share;
 }
 
 
+MaybeObject* Heap::AllocateOptimizedCodeEntry(
+      Context* native_context,
+      JSFunction* function,
+      Code* code,
+      FixedArray* literals) {
+  OptimizedCodeEntry* entry;
+  MaybeObject* maybe = Allocate(optimized_code_entry_map(), OLD_POINTER_SPACE);
+  if (!maybe->To<OptimizedCodeEntry>(&entry)) return maybe;
+
+  // Set pointer fields.
+  entry->set_native_context(native_context, SKIP_WRITE_BARRIER);

[Michael Starzinger, 2013/08/28 14:59:47]

Skipping WBs for all four of these setters is not safe, as any of these objects
might be on evacuation candidates and the entry itself is not in new-space.

+  entry->set_function(function, SKIP_WRITE_BARRIER);
+  entry->set_code(code, SKIP_WRITE_BARRIER);
+  entry->set_literals(literals, SKIP_WRITE_BARRIER);
+
+  // NULL-out link fields.
+  entry->set_next_by_shared_info(NULL, SKIP_WRITE_BARRIER);
+  entry->set_next_by_native_context(NULL, SKIP_WRITE_BARRIER);
+  entry->set_cacheable(false);
+
+  return entry;
+}
+
+
 MaybeObject* Heap::AllocateJSMessageObject(String* type,
                                            JSArray* arguments,
                                            int start_position,
                                            int end_position,
                                            Object* script,
                                            Object* stack_trace,
                                            Object* stack_frames) {
   Object* result;
   { MaybeObject* maybe_result = Allocate(message_object_map(), NEW_SPACE);
     if (!maybe_result->ToObject(&result)) return maybe_result;
@@ skipping 4387 matching lines @@
   if (FLAG_concurrent_recompilation) {
     heap_->relocation_mutex_->Lock();
 #ifdef DEBUG
     heap_->relocation_mutex_locked_by_optimizer_thread_ =
         heap_->isolate()->optimizing_compiler_thread()->IsOptimizerThread();
 #endif  // DEBUG
   }
 }
 
 } }  // namespace v8::internal