Stop "cooking" targets of jumps and calls in code objects. Do not convert ju...

src/heap.cc

 // Copyright 2009 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 619 matching lines @@
 };
 
 
 static void VerifyNonPointerSpacePointers() {
   // Verify that there are no pointers to new space in spaces where we
   // do not expect them.
   VerifyNonPointerSpacePointersVisitor v;
   HeapObjectIterator code_it(Heap::code_space());
   while (code_it.has_next()) {
     HeapObject* object = code_it.next();
-    if (object->IsCode()) {
-      Code::cast(object)->ConvertICTargetsFromAddressToObject();
-      object->Iterate(&v);
-      Code::cast(object)->ConvertICTargetsFromObjectToAddress();
-    } else {
-      // If we find non-code objects in code space (e.g., free list
-      // nodes) we want to verify them as well.
-      object->Iterate(&v);
-    }
+    object->Iterate(&v);
   }
 
   HeapObjectIterator data_it(Heap::old_data_space());
   while (data_it.has_next()) data_it.next()->Iterate(&v);
 }
 #endif
 
 
 void Heap::Scavenge() {
 #ifdef DEBUG
@@ skipping 1269 matching lines @@
 
   if (result->IsFailure()) return result;
 
   // Initialize the object
   HeapObject::cast(result)->set_map(code_map());
   Code* code = Code::cast(result);
   code->set_instruction_size(desc.instr_size);
   code->set_relocation_size(desc.reloc_size);
   code->set_sinfo_size(sinfo_size);
   code->set_flags(flags);
-  code->set_ic_flag(Code::IC_TARGET_IS_ADDRESS);
   // Allow self references to created code object by patching the handle to
   // point to the newly allocated Code object.
   if (!self_reference.is_null()) {
     *(self_reference.location()) = code;
   }
   // Migrate generated code.
   // The generated code can contain Object** values (typically from handles)
   // that are dereferenced during the copy to point directly to the actual heap
   // objects. These pointers can include references to the code object itself,
   // through the self_reference parameter.
@@ skipping 1631 matching lines @@
   if (!map->IsHeapObject()) return;  // visited before
 
   if (found_target) return;  // stop if target found
   object_stack.Add(obj);
   if ((search_for_any_global && obj->IsJSGlobalObject()) ||
       (!search_for_any_global && (obj == search_target))) {
     found_target = true;
     return;
   }
 
-  if (obj->IsCode()) {
-    Code::cast(obj)->ConvertICTargetsFromAddressToObject();
-  }
-
   // not visited yet
   Map* map_p = reinterpret_cast<Map*>(HeapObject::cast(map));
 
   Address map_addr = map_p->address();
 
   obj->set_map(reinterpret_cast<Map*>(map_addr + kMarkTag));
 
   MarkObjectRecursively(&map);
 
   obj->IterateBody(map_p->instance_type(), obj->SizeFromMap(map_p),
@@ skipping 35 matching lines @@
 
   HeapObject* map_p = HeapObject::FromAddress(map_addr);
 
   obj->set_map(reinterpret_cast<Map*>(map_p));
 
   UnmarkObjectRecursively(reinterpret_cast<Object**>(&map_p));
 
   obj->IterateBody(Map::cast(map_p)->instance_type(),
                    obj->SizeFromMap(Map::cast(map_p)),
                    &unmark_visitor);
-
-  if (obj->IsCode()) {
-    Code::cast(obj)->ConvertICTargetsFromObjectToAddress();
-  }
 }
 
 
 static void MarkRootObjectRecursively(Object** root) {
   if (search_for_any_global) {
     ASSERT(search_target == NULL);
   } else {
     ASSERT(search_target->IsHeapObject());
   }
   found_target = false;
@@ skipping 179 matching lines @@
   for (int i = 0; i < kNumberOfCaches; i++) {
     if (caches_[i] != NULL) {
       delete caches_[i];
       caches_[i] = NULL;
     }
   }
 }
 
 
 } }  // namespace v8::internal