- Continue removing [static] qualifier from StubCache.

src/stub-cache.h

 // Copyright 2006-2008 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 156 matching lines @@
   Object* ComputeCallGlobal(int argc,
                             InLoopFlag in_loop,
                             String* name,
                             JSObject* receiver,
                             GlobalObject* holder,
                             JSGlobalPropertyCell* cell,
                             JSFunction* function);
 
   // ---
 
-  static Object* ComputeCallInitialize(int argc, InLoopFlag in_loop);
-  static Object* ComputeCallPreMonomorphic(int argc, InLoopFlag in_loop);
+  Object* ComputeCallInitialize(int argc, InLoopFlag in_loop);
+  Object* ComputeCallPreMonomorphic(int argc, InLoopFlag in_loop);
   Object* ComputeCallNormal(int argc, InLoopFlag in_loop);
   Object* ComputeCallMegamorphic(int argc, InLoopFlag in_loop);
   Object* ComputeCallMiss(int argc);
 
   // Finds the Code object stored in the Heap::non_monomorphic_cache().
   Code* FindCallInitialize(int argc, InLoopFlag in_loop);
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   Object* ComputeCallDebugBreak(int argc);
   Object* ComputeCallDebugPrepareStepIn(int argc);
 #endif
 
-  static Object* ComputeLazyCompile(int argc);
+  Object* ComputeLazyCompile(int argc);
 
 
   // Update cache for entry hash(name, map).
-  static Code* Set(String* name, Map* map, Code* code);
+  Code* Set(String* name, Map* map, Code* code);
 
   // Clear the lookup table (@ mark compact collection).
   void Clear();
 
   // Functions for generating stubs at startup.
-  static void GenerateMiss(MacroAssembler* masm);
+  void GenerateMiss(MacroAssembler* masm);
 
   // Generate code for probing the stub cache table.
   // If extra != no_reg it might be used as am extra scratch register.
-  static void GenerateProbe(MacroAssembler* masm,
-                            Code::Flags flags,
-                            Register receiver,
-                            Register name,
-                            Register scratch,
-                            Register extra);
+  void GenerateProbe(MacroAssembler* masm,
+                     Code::Flags flags,
+                     Register receiver,
+                     Register name,
+                     Register scratch,
+                     Register extra);
 
   enum Table {
     kPrimary,
     kSecondary
   };
 
  private:
   StubCache();
 
   friend class Isolate;
   friend class SCTableReference;
   static const int kPrimaryTableSize = 2048;
   static const int kSecondaryTableSize = 512;
   static Entry primary_[];
   static Entry secondary_[];
 
   // Computes the hashed offsets for primary and secondary caches.
-  static int PrimaryOffset(String* name, Code::Flags flags, Map* map) {
+  RLYSTC int PrimaryOffset(String* name, Code::Flags flags, Map* map) {
     // This works well because the heap object tag size and the hash
     // shift are equal.  Shifting down the length field to get the
     // hash code would effectively throw away two bits of the hash
     // code.
     ASSERT(kHeapObjectTagSize == String::kHashShift);
     // Compute the hash of the name (use entire hash field).
     ASSERT(name->HasHashCode());
     uint32_t field = name->hash_field();
     // Using only the low bits in 64-bit mode is unlikely to increase the
     // risk of collision even if the heap is spread over an area larger than
     // 4Gb (and not at all if it isn't).
     uint32_t map_low32bits =
         static_cast<uint32_t>(reinterpret_cast<uintptr_t>(map));
     // We always set the in_loop bit to zero when generating the lookup code
     // so do it here too so the hash codes match.
     uint32_t iflags =
         (static_cast<uint32_t>(flags) & ~Code::kFlagsNotUsedInLookup);
     // Base the offset on a simple combination of name, flags, and map.
     uint32_t key = (map_low32bits + field) ^ iflags;
     return key & ((kPrimaryTableSize - 1) << kHeapObjectTagSize);
   }
 
-  static int SecondaryOffset(String* name, Code::Flags flags, int seed) {
+  RLYSTC int SecondaryOffset(String* name, Code::Flags flags, int seed) {
     // Use the seed from the primary cache in the secondary cache.
     uint32_t string_low32bits =
         static_cast<uint32_t>(reinterpret_cast<uintptr_t>(name));
     // We always set the in_loop bit to zero when generating the lookup code
     // so do it here too so the hash codes match.
     uint32_t iflags =
         (static_cast<uint32_t>(flags) & ~Code::kFlagsICInLoopMask);
     uint32_t key = seed - string_low32bits + iflags;
     return key & ((kSecondaryTableSize - 1) << kHeapObjectTagSize);
   }
 
   // Compute the entry for a given offset in exactly the same way as
   // we do in generated code.  We generate an hash code that already
   // ends in String::kHashShift 0s.  Then we shift it so it is a multiple
   // of sizeof(Entry).  This makes it easier to avoid making mistakes
   // in the hashed offset computations.
-  static Entry* entry(Entry* table, int offset) {
+  RLYSTC Entry* entry(Entry* table, int offset) {
     const int shift_amount = kPointerSizeLog2 + 1 - String::kHashShift;
     return reinterpret_cast<Entry*>(
         reinterpret_cast<Address>(table) + (offset << shift_amount));
   }
 
   DISALLOW_COPY_AND_ASSIGN(StubCache);
 };
 
 
 class SCTableReference {
@@ skipping 418 matching lines @@
 
   JSFunction* constant_function_;
   bool is_simple_api_call_;
   FunctionTemplateInfo* expected_receiver_type_;
   CallHandlerInfo* api_call_info_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_STUB_CACHE_H_