Now that the macro-assembler functions are not templatized on

src/ia32/macro-assembler-ia32.h

 // Copyright 2011 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 62 matching lines @@
                                            Register value,
                                            Register address);
 
   // For page containing |object| mark region covering |addr| dirty.
   // RememberedSetHelper only works if the object is not in new
   // space.
   void RememberedSetHelper(Register addr,
                            Register scratch,
                            SaveFPRegsMode save_fp);
 
-  inline void CheckPageFlag(
-      Register object,
-      Register scratch,
-      MemoryChunk::MemoryChunkFlags flag,
-      Condition cc,
-      Label* condition_met,
-      Label::Distance condition_met_distance = Label::kFar);
+  void CheckPageFlag(Register object,
+                     Register scratch,
+                     MemoryChunk::MemoryChunkFlags flag,
+                     Condition cc,
+                     Label* condition_met,
+                     Label::Distance condition_met_distance = Label::kFar);
 
 
   void InNewSpace(Register object,
                   Register scratch,
                   Condition cc,
                   Label* condition_met,
                   Label::Distance condition_met_distance = Label::kFar);
 
   // Check if an object has a given incremental marking colour.  Also uses ecx!
   // The colour bits are found by splitting the address at the bit offset
   // indicated by the mask: bits that are zero in the mask are used for the
   // address of the bitmap, and bits that are one in the mask are used for the
   // index of the bit.
-  inline void HasColour(Register object,
-                        Register scratch0,
-                        Register scratch1,
-                        Label* has_colour,
-                        Label::Distance has_colour_distance,
-                        int first_bit,
-                        int second_bit);
+  void HasColour(Register object,
+                 Register scratch0,
+                 Register scratch1,
+                 Label* has_colour,
+                 Label::Distance has_colour_distance,
+                 int first_bit,
+                 int second_bit);
 
-  inline void IsBlack(Register object,
-                      Register scratch0,
-                      Register scratch1,
-                      Label* is_black,
-                      Label::Distance is_black_distance = Label::kFar);
+  void IsBlack(Register object,
+               Register scratch0,
+               Register scratch1,
+               Label* is_black,
+               Label::Distance is_black_distance = Label::kFar);
 
   // Checks the colour of an object.  If the object is already grey or black
   // then we just fall through, since it is already live.  If it is white and
   // we can determine that it doesn't need to be scanned, then we just mark it
   // black and fall through.  For the rest we jump to the label so the
   // incremental marker can fix its assumptions.
-  inline void EnsureNotWhite(Register object,
-                             Register scratch1,
-                             Register scratch2,
-                             Label* object_is_white_and_not_data,
-                             Label::Distance distance,
-                             bool in_new_space);
+  void EnsureNotWhite(Register object,
+                      Register scratch1,
+                      Register scratch2,
+                      Label* object_is_white_and_not_data,
+                      Label::Distance distance,
+                      bool in_new_space);
 
   // Checks whether an object is data-only, ie it does need to be scanned by the
   // garbage collector.
-  inline void IsDataObject(Register value,
-                           Register scratch,
-                           Label* not_data_object,
-                           Label::Distance not_data_object_distance,
-                           bool in_new_space);
+  void IsDataObject(Register value,
+                    Register scratch,
+                    Label* not_data_object,
+                    Label::Distance not_data_object_distance,
+                    bool in_new_space);
 
   // Notify the garbage collector that we wrote a pointer into an object.
   // |object| is the object being stored into, |value| is the object being
   // stored.  All registers are clobbered by the operation.  RecordWriteField
   // filters out smis so it does not update the write barrier if the value is a
   // smi.  The offset is the offset from the start of the object, not the offset
   // from the tagged HeapObject pointer.  For use with FieldOperand(reg, off).
   void RecordWriteField(
       Register object,
       int offset,
       Register value,
       Register scratch,
       SaveFPRegsMode save_fp,
       EmitRememberedSet emit_remembered_set = EMIT_REMEMBERED_SET,
       SmiCheck smi_check = INLINE_SMI_CHECK);
 
   // As above, but the offset has the tag presubtracted.  For use with
   // Operand(reg, off).
-  inline void RecordWriteContextSlot(
+  void RecordWriteContextSlot(
       Register context,
       int offset,
       Register value,
       Register scratch,
       SaveFPRegsMode save_fp,
       EmitRememberedSet emit_remembered_set = EMIT_REMEMBERED_SET,
       SmiCheck smi_check = INLINE_SMI_CHECK) {
     RecordWriteField(context,
                      offset + kHeapObjectTag,
                      value,
@@ skipping 704 matching lines @@
   }                                                                       \
   masm->
 #else
 #define ACCESS_MASM(masm) masm->
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_IA32_MACRO_ASSEMBLER_IA32_H_