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

runtime/vm/code_index_table.h

 // Copyright (c) 2012, 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.
 
 #ifndef VM_CODE_INDEX_TABLE_H_
 #define VM_CODE_INDEX_TABLE_H_
 
 #include "platform/assert.h"
 #include "vm/globals.h"
 
 namespace dart {
 
 // Forward declarations.
 class Array;
 class Code;
 class Function;
 class Isolate;
 class ObjectPointerVisitor;
 class RawArray;
 class RawCode;
 class RawFunction;
 
-// This class is used to lookup a Function object given a pc.
+// This class is used to lookup a Code object given a pc.
 // This functionality is used while stack walking in order to find the Dart
 // function corresponding to a frame (enables the pc descriptors for
 // a stack frame to be located).
-// Most functions fit within a normal page (PageSpace::KPageSize) but some
-// functions may have code which is larger than the size of a normal page.
-// These functions are referred to as large functions in this code and are
+// Most code objects fit within a normal page (PageSpace::KPageSize) but some
+// code objects may be larger than the size of a normal page.
+// These code objects are referred to as "large codes" in this code and are
 // handled by maintaining separate index lists.
 class CodeIndexTable {
  public:
   ~CodeIndexTable();
 
   // Add specified compiled function to the code index table.
-  void AddFunction(const Function& func);
+  void AddCode(const Code& code);
 
-  // Lookup code index table to find the function corresponding to the
-  // specified 'pc'. If there is no corresponding function a null object
+  // Lookup code index table to find the code object corresponding to the
+  // specified 'pc'. If there is no corresponding code object a null object
   // is returned.
-  RawFunction* LookupFunction(uword pc) const;
-
-  // Lookup code index table to find corresponding code object.
   RawCode* LookupCode(uword pc) const;
 
   // Visit all object pointers (support for GC).
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   // Initialize the code index table for specified isolate.
   static void Init(Isolate* isolate);
 
  private:
   static const int kInitialSize = 16;
@@ skipping 60 matching lines @@
 
   // Constructor.
   CodeIndexTable();
 
   // Add code page information to the index table.
   int AddPageIndex(uword page_start);
 
   // Find the index corresponding to the code page in the index table.
   int FindPageIndex(uword page_start) const;
 
-  // Add information about a function (entrypoint, size, function object)
+  // Add information about a code object (entrypoint, size, code object)
   // at the specified index of the index table.
-  void AddFunctionToList(int page_index,
-                         uword entrypoint,
-                         intptr_t size,
-                         const Function& func);
-
-  // Add information about a large function (entrypoint, size, function object)
-  // to the large function list.
-  void AddLargeFunction(uword entrypoint, intptr_t size, const Function& func);
-
-  // Helper function to add a function to the list.
-  void AddFuncHelper(IndexArray<PcRange>* pc_ranges,
-                     const Array& functions,
+  void AddCodeToList(int page_index,
                      uword entrypoint,
                      intptr_t size,
-                     const Function& func);
+                     const Code& code);
+
+  // Add information about a large code object (entrypoint, size, code object)
+  // to the large code object list.
+  void AddLargeCode(uword entrypoint, intptr_t size, const Code& code);
+
+  // Helper function to add a code object to the list.
+  void AddCodeHelper(IndexArray<PcRange>* pc_ranges,
+                     const Array& codes,
+                     uword entrypoint,
+                     intptr_t size,
+                     const Code& func);
 
   // Lookup code corresponding to the pc in the large functions list
   RawCode* LookupLargeCode(uword pc) const;
 
   // Lookup code corresponding to the pc in the functions list
   // present at the specified page index.
   static RawCode* LookupCodeFromList(IndexArray<PcRange>* pc_ranges,
                                      const Array& functions,
                                      uword pc,
                                      bool sorted);
@@ skipping 11 matching lines @@
   RawArray* code_lists_;  // Array of pointers to code lists (arrays).
   IndexArray<PcRange>* largecode_pc_ranges_;  // pc ranges of large codes.
   RawArray* largecode_list_;  // Array of pointer to large code objects.
 
   DISALLOW_COPY_AND_ASSIGN(CodeIndexTable);
 };
 
 }  // namespace dart
 
 #endif  // VM_CODE_INDEX_TABLE_H_