Cleaned up usage of Function::code, since it may be misunderstood that it points to the only Code o…

runtime/vm/code_index_table.cc

 // 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"
@@ skipping 16 matching lines @@
     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::AddFunction(const Function& func) {
-  const Code& code = Code::Handle(func.code());
+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.
-    AddFunctionToList(page_index, entrypoint, instr_size, func);
+    AddCodeToList(page_index, entrypoint, instr_size, code);
   } else {
-    AddLargeFunction(entrypoint, instr_size, func);
+    AddLargeCode(entrypoint, instr_size, code);
   }
 }
 
 
-RawFunction* CodeIndexTable::LookupFunction(uword pc) const {
-  const Code& code = Code::Handle(LookupCode(pc));
-  if (code.IsNull()) {
-    return Function::null();
-  }
-  return code.function();
-}
-
-
 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;
@@ skipping 47 matching lines @@
   // 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::AddFunctionToList(int page_index,
-                                       uword entrypoint,
-                                       intptr_t size,
-                                       const Function& func) {
+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);
-  AddFuncHelper(pc_ranges, codes, entrypoint, size, func);
+  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::AddLargeFunction(uword entrypoint,
-                                      intptr_t size,
-                                      const Function& func) {
+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());
-  AddFuncHelper(largecode_pc_ranges_, largecode_list, entrypoint, size, func);
+  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::AddFuncHelper(IndexArray<PcRange>* pc_ranges,
+void CodeIndexTable::AddCodeHelper(IndexArray<PcRange>* pc_ranges,
                                    const Array& codes,
                                    uword entrypoint,
                                    intptr_t size,
-                                   const Function& func) {
+                                   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::Handle(func.code()));
+  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);
 }
@@ skipping 55 matching lines @@
   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