Revision: 9336
Author: [email protected]
Date: Tue Sep 20 03:08:39 2011
Log: Fix pc to code cache so it can cope with a pointer to the start
of the code
object. Rename it to be the inner pointer to code cache.
Review URL: http://codereview.chromium.org/7969013
http://code.google.com/p/v8/source/detail?r=9336
Modified:
/branches/bleeding_edge/src/frames-inl.h
/branches/bleeding_edge/src/frames.cc
/branches/bleeding_edge/src/frames.h
/branches/bleeding_edge/src/heap.cc
/branches/bleeding_edge/src/incremental-marking.cc
/branches/bleeding_edge/src/isolate.cc
/branches/bleeding_edge/src/isolate.h
/branches/bleeding_edge/src/mark-compact.cc
/branches/bleeding_edge/src/objects-inl.h
=======================================
--- /branches/bleeding_edge/src/frames-inl.h Fri Aug 12 03:52:49 2011
+++ /branches/bleeding_edge/src/frames-inl.h Tue Sep 20 03:08:39 2011
@@ -106,7 +106,7 @@
inline Code* StackFrame::GetContainingCode(Isolate* isolate, Address pc) {
- return isolate->pc_to_code_cache()->GetCacheEntry(pc)->code;
+ return isolate->inner_pointer_to_code_cache()->GetCacheEntry(pc)->code;
}
=======================================
--- /branches/bleeding_edge/src/frames.cc Mon Sep 19 11:36:47 2011
+++ /branches/bleeding_edge/src/frames.cc Tue Sep 20 03:08:39 2011
@@ -366,16 +366,17 @@
Code* StackFrame::GetSafepointData(Isolate* isolate,
- Address pc,
+ Address inner_pointer,
SafepointEntry* safepoint_entry,
unsigned* stack_slots) {
- PcToCodeCache::PcToCodeCacheEntry* entry =
- isolate->pc_to_code_cache()->GetCacheEntry(pc);
+ InnerPointerToCodeCache::InnerPointerToCodeCacheEntry* entry =
+ isolate->inner_pointer_to_code_cache()->GetCacheEntry(inner_pointer);
if (!entry->safepoint_entry.is_valid()) {
- entry->safepoint_entry = entry->code->GetSafepointEntry(pc);
+ entry->safepoint_entry = entry->code->GetSafepointEntry(inner_pointer);
ASSERT(entry->safepoint_entry.is_valid());
} else {
-
ASSERT(entry->safepoint_entry.Equals(entry->code->GetSafepointEntry(pc)));
+ ASSERT(entry->safepoint_entry.Equals(
+ entry->code->GetSafepointEntry(inner_pointer)));
}
// Fill in the results and return the code.
@@ -819,7 +820,8 @@
// back to a slow search in this case to find the original optimized
// code object.
if (!code->contains(pc())) {
- code = isolate()->pc_to_code_cache()->GcSafeFindCodeForPc(pc());
+ code = isolate()->inner_pointer_to_code_cache()->
+ GcSafeFindCodeForInnerPointer(pc());
}
ASSERT(code != NULL);
ASSERT(code->kind() == Code::OPTIMIZED_FUNCTION);
@@ -1155,9 +1157,10 @@
//
-------------------------------------------------------------------------
-Code* PcToCodeCache::GcSafeCastToCode(HeapObject* object, Address pc) {
+Code* InnerPointerToCodeCache::GcSafeCastToCode(HeapObject* object,
+ Address inner_pointer) {
Code* code = reinterpret_cast<Code*>(object);
- ASSERT(code != NULL && code->contains(pc));
+ ASSERT(code != NULL && code->contains(inner_pointer));
return code;
}
@@ -1170,17 +1173,20 @@
}
-Code* PcToCodeCache::GcSafeFindCodeForPc(Address pc) {
+Code* InnerPointerToCodeCache::GcSafeFindCodeForInnerPointer(
+ Address inner_pointer) {
Heap* heap = isolate_->heap();
- // Check if the pc points into a large object chunk.
- LargePage* large_page = heap->lo_space()->FindPageContainingPc(pc);
- if (large_page != NULL) return GcSafeCastToCode(large_page->GetObject(),
pc);
+ // Check if the inner pointer points into a large object chunk.
+ LargePage* large_page =
heap->lo_space()->FindPageContainingPc(inner_pointer);
+ if (large_page != NULL) {
+ return GcSafeCastToCode(large_page->GetObject(), inner_pointer);
+ }
// Iterate through the page until we reach the end or find an object
starting
- // after the pc.
- Page* page = Page::FromAddress(pc);
-
- Address addr = page->skip_list()->StartFor(pc);
+ // after the inner pointer.
+ Page* page = Page::FromAddress(inner_pointer);
+
+ Address addr = page->skip_list()->StartFor(inner_pointer);
Address top = heap->code_space()->top();
Address limit = heap->code_space()->limit();
@@ -1194,30 +1200,31 @@
HeapObject* obj = HeapObject::FromAddress(addr);
int obj_size = GcSafeSizeOfCodeSpaceObject(obj);
Address next_addr = addr + obj_size;
- if (next_addr >= pc) return GcSafeCastToCode(obj, pc);
+ if (next_addr > inner_pointer) return GcSafeCastToCode(obj,
inner_pointer);
addr = next_addr;
}
}
-PcToCodeCache::PcToCodeCacheEntry* PcToCodeCache::GetCacheEntry(Address
pc) {
+InnerPointerToCodeCache::InnerPointerToCodeCacheEntry*
+ InnerPointerToCodeCache::GetCacheEntry(Address inner_pointer) {
isolate_->counters()->pc_to_code()->Increment();
- ASSERT(IsPowerOf2(kPcToCodeCacheSize));
+ ASSERT(IsPowerOf2(kInnerPointerToCodeCacheSize));
uint32_t hash = ComputeIntegerHash(
- static_cast<uint32_t>(reinterpret_cast<uintptr_t>(pc)));
- uint32_t index = hash & (kPcToCodeCacheSize - 1);
- PcToCodeCacheEntry* entry = cache(index);
- if (entry->pc == pc) {
+ static_cast<uint32_t>(reinterpret_cast<uintptr_t>(inner_pointer)));
+ uint32_t index = hash & (kInnerPointerToCodeCacheSize - 1);
+ InnerPointerToCodeCacheEntry* entry = cache(index);
+ if (entry->inner_pointer == inner_pointer) {
isolate_->counters()->pc_to_code_cached()->Increment();
- ASSERT(entry->code == GcSafeFindCodeForPc(pc));
+ ASSERT(entry->code == GcSafeFindCodeForInnerPointer(inner_pointer));
} else {
// Because this code may be interrupted by a profiling signal that
- // also queries the cache, we cannot update pc before the code has
- // been set. Otherwise, we risk trying to use a cache entry before
+ // also queries the cache, we cannot update inner_pointer before the
code
+ // has been set. Otherwise, we risk trying to use a cache entry before
// the code has been computed.
- entry->code = GcSafeFindCodeForPc(pc);
+ entry->code = GcSafeFindCodeForInnerPointer(inner_pointer);
entry->safepoint_entry.Reset();
- entry->pc = pc;
+ entry->inner_pointer = inner_pointer;
}
return entry;
}
=======================================
--- /branches/bleeding_edge/src/frames.h Thu Sep 15 04:30:45 2011
+++ /branches/bleeding_edge/src/frames.h Tue Sep 20 03:08:39 2011
@@ -49,36 +49,36 @@
class ThreadLocalTop;
class Isolate;
-class PcToCodeCache {
+class InnerPointerToCodeCache {
public:
- struct PcToCodeCacheEntry {
- Address pc;
+ struct InnerPointerToCodeCacheEntry {
+ Address inner_pointer;
Code* code;
SafepointEntry safepoint_entry;
};
- explicit PcToCodeCache(Isolate* isolate) : isolate_(isolate) {
+ explicit InnerPointerToCodeCache(Isolate* isolate) : isolate_(isolate) {
Flush();
}
- Code* GcSafeFindCodeForPc(Address pc);
- Code* GcSafeCastToCode(HeapObject* object, Address pc);
+ Code* GcSafeFindCodeForInnerPointer(Address inner_pointer);
+ Code* GcSafeCastToCode(HeapObject* object, Address inner_pointer);
void Flush() {
memset(&cache_[0], 0, sizeof(cache_));
}
- PcToCodeCacheEntry* GetCacheEntry(Address pc);
+ InnerPointerToCodeCacheEntry* GetCacheEntry(Address inner_pointer);
private:
- PcToCodeCacheEntry* cache(int index) { return &cache_[index]; }
+ InnerPointerToCodeCacheEntry* cache(int index) { return &cache_[index]; }
Isolate* isolate_;
- static const int kPcToCodeCacheSize = 1024;
- PcToCodeCacheEntry cache_[kPcToCodeCacheSize];
-
- DISALLOW_COPY_AND_ASSIGN(PcToCodeCache);
+ static const int kInnerPointerToCodeCacheSize = 1024;
+ InnerPointerToCodeCacheEntry cache_[kInnerPointerToCodeCacheSize];
+
+ DISALLOW_COPY_AND_ASSIGN(InnerPointerToCodeCache);
};
=======================================
--- /branches/bleeding_edge/src/heap.cc Tue Sep 20 03:06:23 2011
+++ /branches/bleeding_edge/src/heap.cc Tue Sep 20 03:08:39 2011
@@ -844,7 +844,8 @@
Object* Heap::FindCodeObject(Address a) {
- return isolate()->pc_to_code_cache()->GcSafeFindCodeForPc(a);
+ return isolate()->inner_pointer_to_code_cache()->
+ GcSafeFindCodeForInnerPointer(a);
}
=======================================
--- /branches/bleeding_edge/src/incremental-marking.cc Tue Sep 20 02:43:58
2011
+++ /branches/bleeding_edge/src/incremental-marking.cc Tue Sep 20 03:08:39
2011
@@ -87,8 +87,8 @@
void IncrementalMarking::RecordCodeTargetPatch(Address pc, HeapObject*
value) {
if (IsMarking()) {
- Code* host =
- heap_->isolate()->pc_to_code_cache()->GcSafeFindCodeForPc(pc);
+ Code* host = heap_->isolate()->inner_pointer_to_code_cache()->
+ GcSafeFindCodeForInnerPointer(pc);
RelocInfo rinfo(pc, RelocInfo::CODE_TARGET, 0, host);
RecordWriteIntoCode(host, &rinfo, value);
}
=======================================
--- /branches/bleeding_edge/src/isolate.cc Fri Sep 16 06:06:51 2011
+++ /branches/bleeding_edge/src/isolate.cc Tue Sep 20 03:08:39 2011
@@ -1403,7 +1403,7 @@
in_use_list_(0),
free_list_(0),
preallocated_storage_preallocated_(false),
- pc_to_code_cache_(NULL),
+ inner_pointer_to_code_cache_(NULL),
write_input_buffer_(NULL),
global_handles_(NULL),
context_switcher_(NULL),
@@ -1576,8 +1576,8 @@
compilation_cache_ = NULL;
delete bootstrapper_;
bootstrapper_ = NULL;
- delete pc_to_code_cache_;
- pc_to_code_cache_ = NULL;
+ delete inner_pointer_to_code_cache_;
+ inner_pointer_to_code_cache_ = NULL;
delete write_input_buffer_;
write_input_buffer_ = NULL;
@@ -1701,7 +1701,7 @@
context_slot_cache_ = new ContextSlotCache();
descriptor_lookup_cache_ = new DescriptorLookupCache();
unicode_cache_ = new UnicodeCache();
- pc_to_code_cache_ = new PcToCodeCache(this);
+ inner_pointer_to_code_cache_ = new InnerPointerToCodeCache(this);
write_input_buffer_ = new StringInputBuffer();
global_handles_ = new GlobalHandles(this);
bootstrapper_ = new Bootstrapper();
=======================================
--- /branches/bleeding_edge/src/isolate.h Fri Sep 16 06:06:51 2011
+++ /branches/bleeding_edge/src/isolate.h Tue Sep 20 03:08:39 2011
@@ -66,7 +66,7 @@
class HeapProfiler;
class InlineRuntimeFunctionsTable;
class NoAllocationStringAllocator;
-class PcToCodeCache;
+class InnerPointerToCodeCache;
class PreallocatedMemoryThread;
class RegExpStack;
class SaveContext;
@@ -841,7 +841,9 @@
return unicode_cache_;
}
- PcToCodeCache* pc_to_code_cache() { return pc_to_code_cache_; }
+ InnerPointerToCodeCache* inner_pointer_to_code_cache() {
+ return inner_pointer_to_code_cache_;
+ }
StringInputBuffer* write_input_buffer() { return write_input_buffer_; }
@@ -1136,7 +1138,7 @@
PreallocatedStorage in_use_list_;
PreallocatedStorage free_list_;
bool preallocated_storage_preallocated_;
- PcToCodeCache* pc_to_code_cache_;
+ InnerPointerToCodeCache* inner_pointer_to_code_cache_;
StringInputBuffer* write_input_buffer_;
GlobalHandles* global_handles_;
ContextSwitcher* context_switcher_;
=======================================
--- /branches/bleeding_edge/src/mark-compact.cc Tue Sep 20 02:43:58 2011
+++ /branches/bleeding_edge/src/mark-compact.cc Tue Sep 20 03:08:39 2011
@@ -281,7 +281,7 @@
if (!collect_maps_) ReattachInitialMaps();
- heap_->isolate()->pc_to_code_cache()->Flush();
+ heap_->isolate()->inner_pointer_to_code_cache()->Flush();
Finish();
=======================================
--- /branches/bleeding_edge/src/objects-inl.h Tue Sep 20 03:06:23 2011
+++ /branches/bleeding_edge/src/objects-inl.h Tue Sep 20 03:08:39 2011
@@ -3864,9 +3864,8 @@
}
-bool Code::contains(byte* pc) {
- return (instruction_start() <= pc) &&
- (pc <= instruction_start() + instruction_size());
+bool Code::contains(byte* inner_pointer) {
+ return (address() <= inner_pointer) && (inner_pointer <= address() +
Size());
}
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
