Force inlining of object visiting functions.

src/objects-visiting.h

 // Copyright 2012 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 203 matching lines @@
     Object** end_slot = reinterpret_cast<Object**>(object->address() +
                                                    end_offset);
     StaticVisitor::VisitPointers(heap, start_slot, end_slot);
   }
 };
 
 
 template<typename StaticVisitor, typename BodyDescriptor, typename ReturnType>
 class FlexibleBodyVisitor : public BodyVisitorBase<StaticVisitor> {
  public:
-  static inline ReturnType Visit(Map* map, HeapObject* object) {
+  INLINE(static ReturnType Visit(Map* map, HeapObject* object)) {
     int object_size = BodyDescriptor::SizeOf(map, object);
     BodyVisitorBase<StaticVisitor>::IteratePointers(
         map->GetHeap(),
         object,
         BodyDescriptor::kStartOffset,
         object_size);
     return static_cast<ReturnType>(object_size);
   }
 
   template<int object_size>
   static inline ReturnType VisitSpecialized(Map* map, HeapObject* object) {
     ASSERT(BodyDescriptor::SizeOf(map, object) == object_size);
     BodyVisitorBase<StaticVisitor>::IteratePointers(
         map->GetHeap(),
         object,
         BodyDescriptor::kStartOffset,
         object_size);
     return static_cast<ReturnType>(object_size);
   }
 };
 
 
 template<typename StaticVisitor, typename BodyDescriptor, typename ReturnType>
 class FixedBodyVisitor : public BodyVisitorBase<StaticVisitor> {
  public:
-  static inline ReturnType Visit(Map* map, HeapObject* object) {
+  INLINE(static ReturnType Visit(Map* map, HeapObject* object)) {
     BodyVisitorBase<StaticVisitor>::IteratePointers(
         map->GetHeap(),
         object,
         BodyDescriptor::kStartOffset,
         BodyDescriptor::kEndOffset);
     return static_cast<ReturnType>(BodyDescriptor::kSize);
   }
 };
 
 
@@ skipping 11 matching lines @@
 //
 // This is an example of Curiously recurring template pattern
 // (see http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern).
 // We use CRTP to guarantee aggressive compile time optimizations (i.e.
 // inlining and specialization of StaticVisitor::VisitPointers methods).
 template<typename StaticVisitor>
 class StaticNewSpaceVisitor : public StaticVisitorBase {
  public:
   static void Initialize();
 
-  static inline int IterateBody(Map* map, HeapObject* obj) {
+  INLINE(static int IterateBody(Map* map, HeapObject* obj)) {
     return table_.GetVisitor(map)(map, obj);
   }
 
-  static inline void VisitPointers(Heap* heap, Object** start, Object** end) {
+  INLINE(static void VisitPointers(Heap* heap, Object** start, Object** end)) {
     for (Object** p = start; p < end; p++) StaticVisitor::VisitPointer(heap, p);
   }
 
  private:
-  static inline int VisitJSFunction(Map* map, HeapObject* object) {
+  INLINE(static int VisitJSFunction(Map* map, HeapObject* object)) {
     Heap* heap = map->GetHeap();
     VisitPointers(heap,
                   HeapObject::RawField(object, JSFunction::kPropertiesOffset),
                   HeapObject::RawField(object, JSFunction::kCodeEntryOffset));
 
     // Don't visit code entry. We are using this visitor only during scavenges.
 
     VisitPointers(
         heap,
         HeapObject::RawField(object,
                              JSFunction::kCodeEntryOffset + kPointerSize),
         HeapObject::RawField(object,
                              JSFunction::kNonWeakFieldsEndOffset));
     return JSFunction::kSize;
   }
 
-  static inline int VisitByteArray(Map* map, HeapObject* object) {
+  INLINE(static int VisitByteArray(Map* map, HeapObject* object)) {
     return reinterpret_cast<ByteArray*>(object)->ByteArraySize();
   }
 
-  static inline int VisitFixedDoubleArray(Map* map, HeapObject* object) {
+  INLINE(static int VisitFixedDoubleArray(Map* map, HeapObject* object)) {
     int length = reinterpret_cast<FixedDoubleArray*>(object)->length();
     return FixedDoubleArray::SizeFor(length);
   }
 
-  static inline int VisitJSObject(Map* map, HeapObject* object) {
+  INLINE(static int VisitJSObject(Map* map, HeapObject* object)) {
     return JSObjectVisitor::Visit(map, object);
   }
 
-  static inline int VisitSeqOneByteString(Map* map, HeapObject* object) {
+  INLINE(static int VisitSeqOneByteString(Map* map, HeapObject* object)) {
     return SeqOneByteString::cast(object)->
         SeqOneByteStringSize(map->instance_type());
   }
 
-  static inline int VisitSeqTwoByteString(Map* map, HeapObject* object) {
+  INLINE(static int VisitSeqTwoByteString(Map* map, HeapObject* object)) {
     return SeqTwoByteString::cast(object)->
         SeqTwoByteStringSize(map->instance_type());
   }
 
-  static inline int VisitFreeSpace(Map* map, HeapObject* object) {
+  INLINE(static int VisitFreeSpace(Map* map, HeapObject* object)) {
     return FreeSpace::cast(object)->Size();
   }
 
   class DataObjectVisitor {
    public:
     template<int object_size>
     static inline int VisitSpecialized(Map* map, HeapObject* object) {
       return object_size;
     }
 
-    static inline int Visit(Map* map, HeapObject* object) {
+    INLINE(static int Visit(Map* map, HeapObject* object)) {
       return map->instance_size();
     }
   };
 
   typedef FlexibleBodyVisitor<StaticVisitor,
                               StructBodyDescriptor,
                               int> StructVisitor;
 
   typedef FlexibleBodyVisitor<StaticVisitor,
                               JSObject::BodyDescriptor,
@@ skipping 22 matching lines @@
 //   class SomeVisitor : public StaticMarkingVisitor<SomeVisitor> {
 //     ...
 //   }
 //
 // This is an example of Curiously recurring template pattern.
 template<typename StaticVisitor>
 class StaticMarkingVisitor : public StaticVisitorBase {
  public:
   static void Initialize();
 
-  static inline void IterateBody(Map* map, HeapObject* obj) {
+  INLINE(static void IterateBody(Map* map, HeapObject* obj)) {
     table_.GetVisitor(map)(map, obj);
   }
 
-  static inline void VisitCodeEntry(Heap* heap, Address entry_address);
-  static inline void VisitEmbeddedPointer(Heap* heap, RelocInfo* rinfo);
-  static inline void VisitGlobalPropertyCell(Heap* heap, RelocInfo* rinfo);
-  static inline void VisitDebugTarget(Heap* heap, RelocInfo* rinfo);
-  static inline void VisitCodeTarget(Heap* heap, RelocInfo* rinfo);
-  static inline void VisitCodeAgeSequence(Heap* heap, RelocInfo* rinfo);
-  static inline void VisitExternalReference(RelocInfo* rinfo) { }
-  static inline void VisitRuntimeEntry(RelocInfo* rinfo) { }
+  INLINE(static void VisitCodeEntry(Heap* heap, Address entry_address));
+  INLINE(static void VisitEmbeddedPointer(Heap* heap, RelocInfo* rinfo));
+  INLINE(static void VisitGlobalPropertyCell(Heap* heap, RelocInfo* rinfo));
+  INLINE(static void VisitDebugTarget(Heap* heap, RelocInfo* rinfo));
+  INLINE(static void VisitCodeTarget(Heap* heap, RelocInfo* rinfo));
+  INLINE(static void VisitCodeAgeSequence(Heap* heap, RelocInfo* rinfo));
+  INLINE(static void VisitExternalReference(RelocInfo* rinfo)) { }
+  INLINE(static void VisitRuntimeEntry(RelocInfo* rinfo)) { }
 
   // TODO(mstarzinger): This should be made protected once refactoring is done.
   // Mark non-optimize code for functions inlined into the given optimized
   // code. This will prevent it from being flushed.
   static void MarkInlinedFunctionsCode(Heap* heap, Code* code);
 
  protected:
-  static inline void VisitMap(Map* map, HeapObject* object);
-  static inline void VisitCode(Map* map, HeapObject* object);
-  static inline void VisitSharedFunctionInfo(Map* map, HeapObject* object);
-  static inline void VisitJSFunction(Map* map, HeapObject* object);
-  static inline void VisitJSRegExp(Map* map, HeapObject* object);
-  static inline void VisitNativeContext(Map* map, HeapObject* object);
+  INLINE(static void VisitMap(Map* map, HeapObject* object));
+  INLINE(static void VisitCode(Map* map, HeapObject* object));
+  INLINE(static void VisitSharedFunctionInfo(Map* map, HeapObject* object));
+  INLINE(static void VisitJSFunction(Map* map, HeapObject* object));
+  INLINE(static void VisitJSRegExp(Map* map, HeapObject* object));
+  INLINE(static void VisitNativeContext(Map* map, HeapObject* object));
 
   // Mark pointers in a Map and its TransitionArray together, possibly
   // treating transitions or back pointers weak.
   static void MarkMapContents(Heap* heap, Map* map);
   static void MarkTransitionArray(Heap* heap, TransitionArray* transitions);
 
   // Code flushing support.
-  static inline bool IsFlushable(Heap* heap, JSFunction* function);
-  static inline bool IsFlushable(Heap* heap, SharedFunctionInfo* shared_info);
+  INLINE(static bool IsFlushable(Heap* heap, JSFunction* function));
+  INLINE(static bool IsFlushable(Heap* heap, SharedFunctionInfo* shared_info));
 
   // Helpers used by code flushing support that visit pointer fields and treat
   // references to code objects either strongly or weakly.
   static void VisitSharedFunctionInfoStrongCode(Heap* heap, HeapObject* object);
   static void VisitSharedFunctionInfoWeakCode(Heap* heap, HeapObject* object);
   static void VisitJSFunctionStrongCode(Heap* heap, HeapObject* object);
   static void VisitJSFunctionWeakCode(Heap* heap, HeapObject* object);
 
   class DataObjectVisitor {
    public:
     template<int size>
     static inline void VisitSpecialized(Map* map, HeapObject* object) {
     }
 
-    static inline void Visit(Map* map, HeapObject* object) {
+    INLINE(static void Visit(Map* map, HeapObject* object)) {
     }
   };
 
   typedef FlexibleBodyVisitor<StaticVisitor,
                               FixedArray::BodyDescriptor,
                               void> FixedArrayVisitor;
 
   typedef FlexibleBodyVisitor<StaticVisitor,
                               JSObject::BodyDescriptor,
                               void> JSObjectVisitor;
 
   typedef FlexibleBodyVisitor<StaticVisitor,
                               StructBodyDescriptor,
                               void> StructObjectVisitor;
 
   typedef void (*Callback)(Map* map, HeapObject* object);
 
   static VisitorDispatchTable<Callback> table_;
 };
 
 
 template<typename StaticVisitor>
 VisitorDispatchTable<typename StaticMarkingVisitor<StaticVisitor>::Callback>
     StaticMarkingVisitor<StaticVisitor>::table_;
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_VISITING_H_