Remove code index table.

vm/code_index_table.cc

Index: vm/code_index_table.cc
===================================================================
--- vm/code_index_table.cc	(revision 6535)
+++ vm/code_index_table.cc	(working copy)
@@ -1,257 +0,0 @@
-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-#include "vm/code_index_table.h"
-
-#include "vm/isolate.h"
-#include "vm/object.h"
-#include "vm/pages.h"
-#include "vm/raw_object.h"
-#include "vm/visitor.h"
-
-namespace dart {
-
-CodeIndexTable::CodeIndexTable() : code_pages_(NULL),
-                                   code_lists_(Array::null()),
-                                   largecode_pc_ranges_(NULL),
-                                   largecode_list_(Array::null()) {
-  code_pages_ = new IndexArray<CodePageInfo>(kInitialSize);
-  ASSERT(code_pages_ != NULL);
-  code_lists_ = Array::New(kInitialSize);
-}
-
-
-CodeIndexTable::~CodeIndexTable() {
-  for (intptr_t i = 0; i < code_pages_->length(); i++) {
-    IndexArray<PcRange>* pc_ranges = code_pages_->At(i).pc_ranges;
-    delete pc_ranges;
-  }
-  delete code_pages_;
-  code_lists_ = Array::null();
-  delete largecode_pc_ranges_;
-  largecode_list_ = Array::null();
-}
-
-
-void CodeIndexTable::AddCode(const Code& code) {
-  ASSERT(!code.IsNull());
-  uword entrypoint = code.EntryPoint();  // Entry point for a function.
-  intptr_t instr_size = code.Size();  // Instructions size for the function.
-  if (PageSpace::IsPageAllocatableSize(instr_size)) {
-    uword page_start = (entrypoint & ~(PageSpace::kPageSize - 1));
-    int page_index = FindPageIndex(page_start);
-    if (page_index == -1) {
-      // We do not have an entry for this code page, add one.
-      page_index = AddPageIndex(page_start);
-    }
-    ASSERT(page_index != -1);
-    // Add the entrypoint, size and function object at the specified index.
-    AddCodeToList(page_index, entrypoint, instr_size, code);
-  } else {
-    AddLargeCode(entrypoint, instr_size, code);
-  }
-}
-
-
-RawCode* CodeIndexTable::LookupCode(uword pc) const {
-  uword page_start = (pc & ~(PageSpace::kPageSize - 1));
-  int page_index = FindPageIndex(page_start);
-  if (page_index == -1) {
-    // Check if the pc exists in the large pc ranges as this might be
-    // the pc of a large code object. This would return the large code
-    // or a null object if it doesn't exist in that list too.
-    return LookupLargeCode(pc);
-  }
-  IndexArray<PcRange>* pc_ranges = code_pages_->At(page_index).pc_ranges;
-  const Array& codes_list = Array::Handle(code_lists_);
-  ASSERT(!codes_list.IsNull());
-  ASSERT(page_index < (codes_list.Length() - 1));
-  Array& codes = Array::Handle();
-  codes ^= codes_list.At(page_index);
-  return LookupCodeFromList(pc_ranges, codes, pc, kIsSorted);
-}
-
-
-void CodeIndexTable::VisitObjectPointers(ObjectPointerVisitor* visitor) {
-  ASSERT(visitor != NULL);
-  visitor->VisitPointer(reinterpret_cast<RawObject**>(&code_lists_));
-  visitor->VisitPointer(reinterpret_cast<RawObject**>(&largecode_list_));
-}
-
-
-void CodeIndexTable::Init(Isolate* isolate) {
-  ASSERT(isolate->code_index_table() == NULL);
-  CodeIndexTable* code_index_table = new CodeIndexTable();
-  isolate->set_code_index_table(code_index_table);
-}
-
-
-int CodeIndexTable::AddPageIndex(uword page_start) {
-  ASSERT(FindPageIndex(page_start) == -1);
-  int page_index = code_pages_->length();
-  CodePageInfo code;
-  code.page_start = page_start;
-  code.pc_ranges = new IndexArray<PcRange>(kInitialSize);
-  ASSERT(code.pc_ranges != NULL);
-  code_pages_->Add(code);  // code gets added at 'index'.
-  const Array& codes_list = Array::Handle(code_lists_);
-  ASSERT(!codes_list.IsNull());
-  const Array& codes = Array::Handle(Array::New(kInitialSize));
-  codes_list.SetAt(page_index, codes);
-  if (code_pages_->IsFull()) {
-    // Grow the index table.
-    int new_size = code_pages_->length() + kInitialSize;
-    GrowCodeIndexTable(new_size);
-  }
-  return page_index;
-}
-
-
-int CodeIndexTable::FindPageIndex(uword page_start) const {
-  // We don't expect too many code pages (maybe max of 16) so it is
-  // ok to scan linearly in order to find the page_start in this index
-  // table.
-  for (int i = 0; i < code_pages_->length(); i++) {
-    if (code_pages_->At(i).page_start == page_start) {
-      return i;
-    }
-  }
-  return -1;
-}
-
-
-void CodeIndexTable::AddCodeToList(int page_index,
-                                   uword entrypoint,
-                                   intptr_t size,
-                                   const Code& code) {
-  // Get PC ranges index array at specified index.
-  IndexArray<PcRange>* pc_ranges = code_pages_->At(page_index).pc_ranges;
-  ASSERT(pc_ranges != NULL);
-  const Array& codes_list = Array::Handle(code_lists_);
-  ASSERT(!codes_list.IsNull());
-  // Get functions array present at specified index.
-  Array& codes = Array::Handle();
-  codes ^= codes_list.At(page_index);
-  ASSERT(!codes.IsNull());
-  // Asserting with an unsorted search, to ensure addition of pc was done right.
-  ASSERT(FindPcIndex(*pc_ranges, entrypoint, kIsNotSorted) == -1);
-  AddCodeHelper(pc_ranges, codes, entrypoint, size, code);
-  if (pc_ranges->IsFull()) {
-    // Grow the pc ranges table and the associated functions table.
-    int new_size = pc_ranges->length() + kInitialSize;
-    pc_ranges->Resize(new_size);
-    codes = Array::Grow(codes, new_size);
-    codes_list.SetAt(page_index, codes);
-  }
-}
-
-
-void CodeIndexTable::AddLargeCode(uword entrypoint,
-                                  intptr_t size,
-                                  const Code& code) {
-  if (largecode_pc_ranges_ == NULL) {
-    // No large functions seen so far.
-    largecode_pc_ranges_ = new IndexArray<PcRange>(kInitialSize);
-    ASSERT(largecode_pc_ranges_ != NULL);
-    largecode_list_ = Array::New(kInitialSize);
-  }
-  ASSERT(FindPcIndex(*largecode_pc_ranges_, entrypoint, kIsNotSorted) == -1);
-  const Array& largecode_list = Array::Handle(largecode_list_);
-  ASSERT(!largecode_list.IsNull());
-  AddCodeHelper(largecode_pc_ranges_, largecode_list, entrypoint, size, code);
-  if (largecode_pc_ranges_->IsFull()) {
-    // Grow largecode_pc_ranges_ and largecode_list_.
-    int new_size = largecode_pc_ranges_->length() + kInitialSize;
-    largecode_pc_ranges_->Resize(new_size);
-    largecode_list_ = Array::Grow(largecode_list, new_size);
-  }
-}
-
-
-void CodeIndexTable::AddCodeHelper(IndexArray<PcRange>* pc_ranges,
-                                   const Array& codes,
-                                   uword entrypoint,
-                                   intptr_t size,
-                                   const Code& code) {
-  PcRange pc_range;
-  pc_range.entrypoint = entrypoint;
-  pc_range.size = size;
-  intptr_t next_slot = pc_ranges->length();
-  pc_ranges->Add(pc_range);  // pc_range gets added at 'next_slot'.
-  codes.SetAt(next_slot, code);
-}
-
-
-RawCode* CodeIndexTable::LookupLargeCode(uword pc) const {
-  const Array& large_codes = Array::Handle(largecode_list_);
-  return LookupCodeFromList(largecode_pc_ranges_,
-                            large_codes,
-                            pc,
-                            kIsNotSorted);
-}
-
-
-RawCode* CodeIndexTable::LookupCodeFromList(
-    IndexArray<PcRange>* pc_ranges,
-    const Array& codes,
-    uword pc,
-    bool sorted) {
-  if (pc_ranges == NULL) {
-    return Code::null();  // no entries in array so return null object.
-  }
-  intptr_t i = FindPcIndex(*pc_ranges, pc, sorted);
-  if (i == -1) {
-    return Code::null();  // no entry for pc, return null object.
-  }
-  // 'i' is in the index which holds the entry for the function,
-  // access the functions array at 'i' and return the function object.
-  ASSERT(!codes.IsNull());
-  ASSERT(i < (codes.Length() - 1));
-  Code& code = Code::Handle();
-  code ^= codes.At(i);
-  return code.raw();
-}
-
-
-intptr_t CodeIndexTable::FindPcIndex(const IndexArray<PcRange>& pc_ranges,
-                                     uword pc,
-                                     bool sorted) {
-  if (sorted) {
-    // The pc range entries are sorted, do a binary search to see if pc exists.
-    intptr_t low = 0;
-    intptr_t high = pc_ranges.length();
-    while (low < high) {
-      intptr_t mid = low + (high - low) / 2;
-      uword entrypoint =  pc_ranges.At(mid).entrypoint;
-      intptr_t size = pc_ranges.At(mid).size;
-      if (entrypoint <= pc) {
-        if (pc < (entrypoint + size)) {
-          return mid;  // Found entry, return index.
-        } else {
-          low = mid + 1;
-        }
-      } else {
-        high = mid;
-      }
-    }
-  } else {
-    // The pc range entries are not sorted, do a linear search.
-    for (intptr_t i = (pc_ranges.length() - 1); i >= 0; i--) {
-      uword entrypoint =  pc_ranges.At(i).entrypoint;
-      intptr_t size = pc_ranges.At(i).size;
-      if (entrypoint <= pc &&  pc < (entrypoint + size)) {
-        return i;  // Found entry, return index.
-      }
-    }
-  }
-  return -1;  // Entry not found.
-}
-
-
-void CodeIndexTable::GrowCodeIndexTable(int new_size) {
-  code_pages_->Resize(new_size);
-  code_lists_ = Array::Grow(Array::Handle(code_lists_), new_size);
-}
-
-}  // namespace dart