2008-12-03 Sam Weinig <sam@webkit.org>
authorweinig@apple.com <weinig@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 4 Dec 2008 00:10:53 +0000 (00:10 +0000)
committerweinig@apple.com <weinig@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 4 Dec 2008 00:10:53 +0000 (00:10 +0000)
        Reviewed by Geoffrey Garen.

        Remove shared AssemblerBuffer 1MB buffer and instead give AssemblerBuffer
        an 256 byte inline capacity.

        1% progression on Sunspider.

        * assembler/AssemblerBuffer.h:
        (JSC::AssemblerBuffer::AssemblerBuffer):
        (JSC::AssemblerBuffer::~AssemblerBuffer):
        (JSC::AssemblerBuffer::grow):
        * assembler/MacroAssembler.h:
        (JSC::MacroAssembler::MacroAssembler):
        * assembler/X86Assembler.h:
        (JSC::X86Assembler::X86Assembler):
        * interpreter/Interpreter.cpp:
        (JSC::Interpreter::Interpreter):
        * interpreter/Interpreter.h:
        * jit/JIT.cpp:
        (JSC::JIT::JIT):
        * parser/Nodes.cpp:
        (JSC::RegExpNode::emitBytecode):
        * runtime/RegExp.cpp:
        (JSC::RegExp::RegExp):
        (JSC::RegExp::create):
        * runtime/RegExp.h:
        * runtime/RegExpConstructor.cpp:
        (JSC::constructRegExp):
        * runtime/RegExpPrototype.cpp:
        (JSC::regExpProtoFuncCompile):
        * runtime/StringPrototype.cpp:
        (JSC::stringProtoFuncMatch):
        (JSC::stringProtoFuncSearch):
        * wrec/WREC.cpp:
        (JSC::WREC::Generator::compileRegExp):
        * wrec/WRECGenerator.h:
        (JSC::WREC::Generator::Generator):
        * wrec/WRECParser.h:
        (JSC::WREC::Parser::Parser):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@38975 268f45cc-cd09-0410-ab3c-d52691b4dbfc

16 files changed:
JavaScriptCore/ChangeLog
JavaScriptCore/assembler/AssemblerBuffer.h
JavaScriptCore/assembler/MacroAssembler.h
JavaScriptCore/assembler/X86Assembler.h
JavaScriptCore/interpreter/Interpreter.cpp
JavaScriptCore/interpreter/Interpreter.h
JavaScriptCore/jit/JIT.cpp
JavaScriptCore/parser/Nodes.cpp
JavaScriptCore/runtime/RegExp.cpp
JavaScriptCore/runtime/RegExp.h
JavaScriptCore/runtime/RegExpConstructor.cpp
JavaScriptCore/runtime/RegExpPrototype.cpp
JavaScriptCore/runtime/StringPrototype.cpp
JavaScriptCore/wrec/WREC.cpp
JavaScriptCore/wrec/WRECGenerator.h
JavaScriptCore/wrec/WRECParser.h

index e44787e..0518829 100644 (file)
@@ -1,3 +1,45 @@
+2008-12-03  Sam Weinig  <sam@webkit.org>
+
+        Reviewed by Geoffrey Garen.
+
+        Remove shared AssemblerBuffer 1MB buffer and instead give AssemblerBuffer
+        an 256 byte inline capacity.
+
+        1% progression on Sunspider.
+
+        * assembler/AssemblerBuffer.h:
+        (JSC::AssemblerBuffer::AssemblerBuffer):
+        (JSC::AssemblerBuffer::~AssemblerBuffer):
+        (JSC::AssemblerBuffer::grow):
+        * assembler/MacroAssembler.h:
+        (JSC::MacroAssembler::MacroAssembler):
+        * assembler/X86Assembler.h:
+        (JSC::X86Assembler::X86Assembler):
+        * interpreter/Interpreter.cpp:
+        (JSC::Interpreter::Interpreter):
+        * interpreter/Interpreter.h:
+        * jit/JIT.cpp:
+        (JSC::JIT::JIT):
+        * parser/Nodes.cpp:
+        (JSC::RegExpNode::emitBytecode):
+        * runtime/RegExp.cpp:
+        (JSC::RegExp::RegExp):
+        (JSC::RegExp::create):
+        * runtime/RegExp.h:
+        * runtime/RegExpConstructor.cpp:
+        (JSC::constructRegExp):
+        * runtime/RegExpPrototype.cpp:
+        (JSC::regExpProtoFuncCompile):
+        * runtime/StringPrototype.cpp:
+        (JSC::stringProtoFuncMatch):
+        (JSC::stringProtoFuncSearch):
+        * wrec/WREC.cpp:
+        (JSC::WREC::Generator::compileRegExp):
+        * wrec/WRECGenerator.h:
+        (JSC::WREC::Generator::Generator):
+        * wrec/WRECParser.h:
+        (JSC::WREC::Parser::Parser):
+
 2008-12-03  Geoffrey Garen  <ggaren@apple.com>
 
         Reviewed by Oliver Hunt, with help from Gavin Barraclough.
index e02f161..4ace3f6 100644 (file)
 namespace JSC {
 
     class AssemblerBuffer {
+        static const int inlineCapacity = 256;
     public:
-        AssemblerBuffer(int capacity)
-            : m_buffer(static_cast<char*>(fastMalloc(capacity)))
-            , m_capacity(capacity)
+        AssemblerBuffer()
+            : m_buffer(m_inlineBuffer)
+            , m_capacity(inlineCapacity)
             , m_size(0)
         {
         }
 
         ~AssemblerBuffer()
         {
-            fastFree(m_buffer);
+            if (m_buffer != m_inlineBuffer)
+                fastFree(m_buffer);
         }
 
         void ensureSpace(int space)
@@ -112,12 +114,6 @@ namespace JSC {
             return m_size;
         }
 
-        AssemblerBuffer* reset()
-        {
-            m_size = 0;
-            return this;
-        }
-
         void* executableCopy()
         {
             if (!m_size)
@@ -135,9 +131,15 @@ namespace JSC {
         void grow()
         {
             m_capacity += m_capacity / 2;
-            m_buffer = static_cast<char*>(fastRealloc(m_buffer, m_capacity));
+
+            if (m_buffer == m_inlineBuffer) {
+                char* newBuffer = static_cast<char*>(fastMalloc(m_capacity));
+                m_buffer = static_cast<char*>(memcpy(newBuffer, m_buffer, m_size));
+            } else
+                m_buffer = static_cast<char*>(fastRealloc(m_buffer, m_capacity));
         }
 
+        char m_inlineBuffer[inlineCapacity];
         char* m_buffer;
         int m_capacity;
         int m_size;
index 75ee3c2..b223448 100644 (file)
@@ -49,8 +49,7 @@ public:
         TimesEight = 8
     };
 
-    MacroAssembler(AssemblerBuffer* assemblerBuffer)
-        : m_assembler(assemblerBuffer)
+    MacroAssembler()
     {
     }
     
index 020380d..2aefc46 100644 (file)
@@ -205,219 +205,217 @@ public:
 
     static const int maxInstructionSize = 16;
 
-    X86Assembler(AssemblerBuffer* m_buffer)
-        : m_buffer(m_buffer)
+    X86Assembler()
     {
-        m_buffer->reset();
     }
 
     void int3()
     {
-        m_buffer->putByte(OP_INT3);
+        m_buffer.putByte(OP_INT3);
     }
     
 #if PLATFORM(X86_64)
     void pushq_r(RegisterID reg)
     {
-        m_buffer->putByte(OP_PUSH_EAX + reg);
+        m_buffer.putByte(OP_PUSH_EAX + reg);
     }
 
     void popq_r(RegisterID reg)
     {
-        m_buffer->putByte(OP_POP_EAX + reg);
+        m_buffer.putByte(OP_POP_EAX + reg);
     }
 #else
     void pushl_r(RegisterID reg)
     {
-        m_buffer->putByte(OP_PUSH_EAX + reg);
+        m_buffer.putByte(OP_PUSH_EAX + reg);
     }
     
     void pushl_m(int offset, RegisterID base)
     {
-        m_buffer->putByte(OP_GROUP5_Ev);
+        m_buffer.putByte(OP_GROUP5_Ev);
         modRm_opm(GROUP5_OP_PUSH, base, offset);
     }
 
     void pushl_i32(int imm)
     {
-        m_buffer->putByte(OP_PUSH_Iz);
-        m_buffer->putInt(imm);
+        m_buffer.putByte(OP_PUSH_Iz);
+        m_buffer.putInt(imm);
     }
     
     void popl_r(RegisterID reg)
     {
-        m_buffer->putByte(OP_POP_EAX + reg);
+        m_buffer.putByte(OP_POP_EAX + reg);
     }
 
     void popl_m(int offset, RegisterID base)
     {
-        m_buffer->putByte(OP_GROUP1A_Ev);
+        m_buffer.putByte(OP_GROUP1A_Ev);
         modRm_opm(GROUP1A_OP_POP, base, offset);
     }
 #endif
     
     void movl_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_MOV_EvGv);
+        m_buffer.putByte(OP_MOV_EvGv);
         modRm_rr(src, dst);
     }
     
 #if PLATFORM(X86_64)
     void movq_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(REX_W);
-        m_buffer->putByte(OP_MOV_EvGv);
+        m_buffer.putByte(REX_W);
+        m_buffer.putByte(OP_MOV_EvGv);
         modRm_rr(src, dst);
     }
 #endif
 
     void addl_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_ADD_EvGv);
+        m_buffer.putByte(OP_ADD_EvGv);
         modRm_rr(src, dst);
     }
 
 #if !PLATFORM(X86_64)
     void addl_i8m(int imm, void* addr)
     {
-        m_buffer->putByte(OP_GROUP1_EvIb);
+        m_buffer.putByte(OP_GROUP1_EvIb);
         modRm_opm(GROUP1_OP_ADD, addr);
-        m_buffer->putByte(imm);
+        m_buffer.putByte(imm);
     }
 #endif
 
     void addl_i8r(int imm, RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP1_EvIb);
+        m_buffer.putByte(OP_GROUP1_EvIb);
         modRm_opr(GROUP1_OP_ADD, dst);
-        m_buffer->putByte(imm);
+        m_buffer.putByte(imm);
     }
 
     void addl_i32r(int imm, RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP1_EvIz);
+        m_buffer.putByte(OP_GROUP1_EvIz);
         modRm_opr(GROUP1_OP_ADD, dst);
-        m_buffer->putInt(imm);
+        m_buffer.putInt(imm);
     }
 
 #if PLATFORM(X86_64)
     void addq_i8r(int imm, RegisterID dst)
     {
-        m_buffer->putByte(REX_W);
-        m_buffer->putByte(OP_GROUP1_EvIb);
+        m_buffer.putByte(REX_W);
+        m_buffer.putByte(OP_GROUP1_EvIb);
         modRm_opr(GROUP1_OP_ADD, dst);
-        m_buffer->putByte(imm);
+        m_buffer.putByte(imm);
     }
 
     void addq_i32r(int imm, RegisterID dst)
     {
-        m_buffer->putByte(REX_W);
-        m_buffer->putByte(OP_GROUP1_EvIz);
+        m_buffer.putByte(REX_W);
+        m_buffer.putByte(OP_GROUP1_EvIz);
         modRm_opr(GROUP1_OP_ADD, dst);
-        m_buffer->putInt(imm);
+        m_buffer.putInt(imm);
     }
 #endif
 
     void addl_mr(int offset, RegisterID base, RegisterID dst)
     {
-        m_buffer->putByte(OP_ADD_GvEv);
+        m_buffer.putByte(OP_ADD_GvEv);
         modRm_rm(dst, base, offset);
     }
 
     void andl_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_AND_EvGv);
+        m_buffer.putByte(OP_AND_EvGv);
         modRm_rr(src, dst);
     }
 
     void andl_i32r(int imm, RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP1_EvIz);
+        m_buffer.putByte(OP_GROUP1_EvIz);
         modRm_opr(GROUP1_OP_AND, dst);
-        m_buffer->putInt(imm);
+        m_buffer.putInt(imm);
     }
 
     void cmpl_i8r(int imm, RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP1_EvIb);
+        m_buffer.putByte(OP_GROUP1_EvIb);
         modRm_opr(GROUP1_OP_CMP, dst);
-        m_buffer->putByte(imm);
+        m_buffer.putByte(imm);
     }
 
     void cmpl_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_CMP_EvGv);
+        m_buffer.putByte(OP_CMP_EvGv);
         modRm_rr(src, dst);
     }
 
     void cmpl_rm(RegisterID src, int offset, RegisterID base)
     {
-        m_buffer->putByte(OP_CMP_EvGv);
+        m_buffer.putByte(OP_CMP_EvGv);
         modRm_rm(src, base, offset);
     }
 
     void cmpl_mr(int offset, RegisterID base, RegisterID dst)
     {
-        m_buffer->putByte(OP_CMP_GvEv);
+        m_buffer.putByte(OP_CMP_GvEv);
         modRm_rm(dst, base, offset);
     }
 
     void cmpl_i32r(int imm, RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP1_EvIz);
+        m_buffer.putByte(OP_GROUP1_EvIz);
         modRm_opr(GROUP1_OP_CMP, dst);
-        m_buffer->putInt(imm);
+        m_buffer.putInt(imm);
     }
 
     void cmpl_i32m(int imm, RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP1_EvIz);
+        m_buffer.putByte(OP_GROUP1_EvIz);
         modRm_opm(GROUP1_OP_CMP, dst);
-        m_buffer->putInt(imm);
+        m_buffer.putInt(imm);
     }
 
     void cmpl_i32m(int imm, int offset, RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP1_EvIz);
+        m_buffer.putByte(OP_GROUP1_EvIz);
         modRm_opm(GROUP1_OP_CMP, dst, offset);
-        m_buffer->putInt(imm);
+        m_buffer.putInt(imm);
     }
 
 #if !PLATFORM(X86_64)
     void cmpl_i32m(int imm, void* addr)
     {
-        m_buffer->putByte(OP_GROUP1_EvIz);
+        m_buffer.putByte(OP_GROUP1_EvIz);
         modRm_opm(GROUP1_OP_CMP, addr);
-        m_buffer->putInt(imm);
+        m_buffer.putInt(imm);
     }
 #endif
 
     void cmpl_i8m(int imm, int offset, RegisterID base, RegisterID index, int scale)
     {
-        m_buffer->putByte(OP_GROUP1_EvIb);
+        m_buffer.putByte(OP_GROUP1_EvIb);
         modRm_opmsib(GROUP1_OP_CMP, base, index, scale, offset);
-        m_buffer->putByte(imm);
+        m_buffer.putByte(imm);
     }
 
     void cmpw_rm(RegisterID src, RegisterID base, RegisterID index, int scale)
     {
-        m_buffer->putByte(PRE_OPERAND_SIZE);
-        m_buffer->putByte(OP_CMP_EvGv);
+        m_buffer.putByte(PRE_OPERAND_SIZE);
+        m_buffer.putByte(OP_CMP_EvGv);
         modRm_rmsib(src, base, index, scale);
     }
 
     void cmpw_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
     {
-        m_buffer->putByte(PRE_OPERAND_SIZE);
-        m_buffer->putByte(OP_CMP_EvGv);
+        m_buffer.putByte(PRE_OPERAND_SIZE);
+        m_buffer.putByte(OP_CMP_EvGv);
         modRm_rmsib(src, base, index, scale, offset);
     }
 
     void sete_r(RegisterID dst)
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP_SETE);
-        m_buffer->putByte(MODRM(3, 0, dst));
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP_SETE);
+        m_buffer.putByte(MODRM(3, 0, dst));
     }
 
     void setz_r(RegisterID dst)
@@ -427,9 +425,9 @@ public:
 
     void setne_r(RegisterID dst)
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP_SETNE);
-        m_buffer->putByte(MODRM(3, 0, dst));
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP_SETNE);
+        m_buffer.putByte(MODRM(3, 0, dst));
     }
 
     void setnz_r(RegisterID dst)
@@ -439,21 +437,21 @@ public:
 
     void orl_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_OR_EvGv);
+        m_buffer.putByte(OP_OR_EvGv);
         modRm_rr(src, dst);
     }
 
     void orl_mr(int offset, RegisterID base, RegisterID dst)
     {
-        m_buffer->putByte(OP_OR_GvEv);
+        m_buffer.putByte(OP_OR_GvEv);
         modRm_rm(dst, base, offset);
     }
 
     void orl_i8r(int imm, RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP1_EvIb);
+        m_buffer.putByte(OP_GROUP1_EvIb);
         modRm_opr(GROUP1_OP_OR, dst);
-        m_buffer->putByte(imm);
+        m_buffer.putByte(imm);
     }
 
     void orl_i32r(int imm, RegisterID dst)
@@ -465,167 +463,167 @@ public:
 
     void subl_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_SUB_EvGv);
+        m_buffer.putByte(OP_SUB_EvGv);
         modRm_rr(src, dst);
     }
 
     void subl_i8r(int imm, RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP1_EvIb);
+        m_buffer.putByte(OP_GROUP1_EvIb);
         modRm_opr(GROUP1_OP_SUB, dst);
-        m_buffer->putByte(imm);
+        m_buffer.putByte(imm);
     }
     
 #if !PLATFORM(X86_64)
     void subl_i8m(int imm, void* addr)
     {
-        m_buffer->putByte(OP_GROUP1_EvIb);
+        m_buffer.putByte(OP_GROUP1_EvIb);
         modRm_opm(GROUP1_OP_SUB, addr);
-        m_buffer->putByte(imm);
+        m_buffer.putByte(imm);
     }
 #endif
 
     void subl_i32r(int imm, RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP1_EvIz);
+        m_buffer.putByte(OP_GROUP1_EvIz);
         modRm_opr(GROUP1_OP_SUB, dst);
-        m_buffer->putInt(imm);
+        m_buffer.putInt(imm);
     }
 
     void subl_mr(int offset, RegisterID base, RegisterID dst)
     {
-        m_buffer->putByte(OP_SUB_GvEv);
+        m_buffer.putByte(OP_SUB_GvEv);
         modRm_rm(dst, base, offset);
     }
 
     void testl_i32r(int imm, RegisterID dst)
     {
-        m_buffer->ensureSpace(maxInstructionSize);
-        m_buffer->putByteUnchecked(OP_GROUP3_EvIz);
+        m_buffer.ensureSpace(maxInstructionSize);
+        m_buffer.putByteUnchecked(OP_GROUP3_EvIz);
         modRm_opr_Unchecked(GROUP3_OP_TEST, dst);
-        m_buffer->putIntUnchecked(imm);
+        m_buffer.putIntUnchecked(imm);
     }
 
     void testl_i32m(int imm, RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP3_EvIz);
+        m_buffer.putByte(OP_GROUP3_EvIz);
         modRm_opm(GROUP3_OP_TEST, dst);
-        m_buffer->putInt(imm);
+        m_buffer.putInt(imm);
     }
 
     void testl_i32m(int imm, int offset, RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP3_EvIz);
+        m_buffer.putByte(OP_GROUP3_EvIz);
         modRm_opm(GROUP3_OP_TEST, dst, offset);
-        m_buffer->putInt(imm);
+        m_buffer.putInt(imm);
     }
 
     void testl_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_TEST_EvGv);
+        m_buffer.putByte(OP_TEST_EvGv);
         modRm_rr(src, dst);
     }
     
     void xorl_i8r(int imm, RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP1_EvIb);
+        m_buffer.putByte(OP_GROUP1_EvIb);
         modRm_opr(GROUP1_OP_XOR, dst);
-        m_buffer->putByte(imm);
+        m_buffer.putByte(imm);
     }
 
     void xorl_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_XOR_EvGv);
+        m_buffer.putByte(OP_XOR_EvGv);
         modRm_rr(src, dst);
     }
 
     void sarl_i8r(int imm, RegisterID dst)
     {
         if (imm == 1) {
-            m_buffer->putByte(OP_GROUP2_Ev1);
+            m_buffer.putByte(OP_GROUP2_Ev1);
             modRm_opr(GROUP2_OP_SAR, dst);
         } else {
-            m_buffer->putByte(OP_GROUP2_EvIb);
+            m_buffer.putByte(OP_GROUP2_EvIb);
             modRm_opr(GROUP2_OP_SAR, dst);
-            m_buffer->putByte(imm);
+            m_buffer.putByte(imm);
         }
     }
 
     void sarl_CLr(RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP2_EvCL);
+        m_buffer.putByte(OP_GROUP2_EvCL);
         modRm_opr(GROUP2_OP_SAR, dst);
     }
 
     void shl_i8r(int imm, RegisterID dst)
     {
         if (imm == 1) {
-            m_buffer->putByte(OP_GROUP2_Ev1);
+            m_buffer.putByte(OP_GROUP2_Ev1);
             modRm_opr(GROUP2_OP_SHL, dst);
         } else {
-            m_buffer->putByte(OP_GROUP2_EvIb);
+            m_buffer.putByte(OP_GROUP2_EvIb);
             modRm_opr(GROUP2_OP_SHL, dst);
-            m_buffer->putByte(imm);
+            m_buffer.putByte(imm);
         }
     }
 
     void shll_CLr(RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP2_EvCL);
+        m_buffer.putByte(OP_GROUP2_EvCL);
         modRm_opr(GROUP2_OP_SHL, dst);
     }
 
     void imull_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_IMUL_GvEv);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_IMUL_GvEv);
         modRm_rr(dst, src);
     }
     
     void imull_i32r(RegisterID src, int32_t value, RegisterID dst)
     {
-        m_buffer->putByte(OP_IMUL_GvEvIz);
+        m_buffer.putByte(OP_IMUL_GvEvIz);
         modRm_rr(dst, src);
-        m_buffer->putInt(value);
+        m_buffer.putInt(value);
     }
 
     void idivl_r(RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP3_Ev);
+        m_buffer.putByte(OP_GROUP3_Ev);
         modRm_opr(GROUP3_OP_IDIV, dst);
     }
 
     void cdq()
     {
-        m_buffer->putByte(OP_CDQ);
+        m_buffer.putByte(OP_CDQ);
     }
 
     void movl_mr(RegisterID base, RegisterID dst)
     {
-        m_buffer->putByte(OP_MOV_GvEv);
+        m_buffer.putByte(OP_MOV_GvEv);
         modRm_rm(dst, base);
     }
 
     void movl_mr(int offset, RegisterID base, RegisterID dst)
     {
-        m_buffer->ensureSpace(maxInstructionSize);
-        m_buffer->putByteUnchecked(OP_MOV_GvEv);
+        m_buffer.ensureSpace(maxInstructionSize);
+        m_buffer.putByteUnchecked(OP_MOV_GvEv);
         modRm_rm_Unchecked(dst, base, offset);
     }
 
 #if PLATFORM(X86_64)
     void movq_mr(RegisterID base, RegisterID dst)
     {
-        m_buffer->putByte(REX_W);
-        m_buffer->putByte(OP_MOV_GvEv);
+        m_buffer.putByte(REX_W);
+        m_buffer.putByte(OP_MOV_GvEv);
         modRm_rm(dst, base);
     }
 
     void movq_mr(int offset, RegisterID base, RegisterID dst)
     {
-        m_buffer->ensureSpace(maxInstructionSize);
-        m_buffer->putByteUnchecked(REX_W);
-        m_buffer->putByteUnchecked(OP_MOV_GvEv);
+        m_buffer.ensureSpace(maxInstructionSize);
+        m_buffer.putByteUnchecked(REX_W);
+        m_buffer.putByteUnchecked(OP_MOV_GvEv);
         modRm_rm_Unchecked(dst, base, offset);
     }
 #endif
@@ -633,279 +631,279 @@ public:
 #if !PLATFORM(X86_64)
     void movl_mr(void* addr, RegisterID dst)
     {
-        m_buffer->putByte(OP_MOV_GvEv);
+        m_buffer.putByte(OP_MOV_GvEv);
         modRm_rm(dst, addr);
     }
 #endif
 
     void movl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
     {
-        m_buffer->putByte(OP_MOV_GvEv);
+        m_buffer.putByte(OP_MOV_GvEv);
         modRm_rmsib(dst, base, index, scale, offset);
     }
 
     void movzbl_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_MOVZX_GvEb);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_MOVZX_GvEb);
         modRm_rr(dst, src);
     }
 
     void movzwl_mr(int offset, RegisterID base, RegisterID dst)
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_MOVZX_GvEw);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_MOVZX_GvEw);
         modRm_rm(dst, base, offset);
     }
 
     void movzwl_mr(RegisterID base, RegisterID index, int scale, RegisterID dst)
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_MOVZX_GvEw);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_MOVZX_GvEw);
         modRm_rmsib(dst, base, index, scale);
     }
 
     void movzwl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_MOVZX_GvEw);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_MOVZX_GvEw);
         modRm_rmsib(dst, base, index, scale, offset);
     }
 
     void movl_rm(RegisterID src, RegisterID base)
     {
-        m_buffer->putByte(OP_MOV_EvGv);
+        m_buffer.putByte(OP_MOV_EvGv);
         modRm_rm(src, base);
     }
 
     void movl_rm(RegisterID src, int offset, RegisterID base)
     {
-        m_buffer->ensureSpace(maxInstructionSize);
-        m_buffer->putByteUnchecked(OP_MOV_EvGv);
+        m_buffer.ensureSpace(maxInstructionSize);
+        m_buffer.putByteUnchecked(OP_MOV_EvGv);
         modRm_rm_Unchecked(src, base, offset);
     }
 
 #if PLATFORM(X86_64)
     void movq_rm(RegisterID src, RegisterID base)
     {
-        m_buffer->putByte(REX_W);
-        m_buffer->putByte(OP_MOV_EvGv);
+        m_buffer.putByte(REX_W);
+        m_buffer.putByte(OP_MOV_EvGv);
         modRm_rm(src, base);
     }
 
     void movq_rm(RegisterID src, int offset, RegisterID base)
     {
-        m_buffer->ensureSpace(maxInstructionSize);
-        m_buffer->putByteUnchecked(REX_W);
-        m_buffer->putByteUnchecked(OP_MOV_EvGv);
+        m_buffer.ensureSpace(maxInstructionSize);
+        m_buffer.putByteUnchecked(REX_W);
+        m_buffer.putByteUnchecked(OP_MOV_EvGv);
         modRm_rm_Unchecked(src, base, offset);
     }
 #endif
 
     void movl_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
     {
-        m_buffer->putByte(OP_MOV_EvGv);
+        m_buffer.putByte(OP_MOV_EvGv);
         modRm_rmsib(src, base, index, scale, offset);
     }
     
     void movl_i32r(int imm, RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP11_EvIz);
+        m_buffer.putByte(OP_GROUP11_EvIz);
         modRm_opr(GROUP11_MOV, dst);
-        m_buffer->putInt(imm);
+        m_buffer.putInt(imm);
     }
 
     void movl_i32m(int imm, int offset, RegisterID base)
     {
-        m_buffer->ensureSpace(maxInstructionSize);
-        m_buffer->putByteUnchecked(OP_GROUP11_EvIz);
+        m_buffer.ensureSpace(maxInstructionSize);
+        m_buffer.putByteUnchecked(OP_GROUP11_EvIz);
         modRm_opm_Unchecked(GROUP11_MOV, base, offset);
-        m_buffer->putIntUnchecked(imm);
+        m_buffer.putIntUnchecked(imm);
     }
 
 #if !PLATFORM(X86_64)
     void movl_i32m(int imm, void* addr)
     {
-        m_buffer->putByte(OP_GROUP11_EvIz);
+        m_buffer.putByte(OP_GROUP11_EvIz);
         modRm_opm(GROUP11_MOV, addr);
-        m_buffer->putInt(imm);
+        m_buffer.putInt(imm);
     }
 #endif
 
     void leal_mr(int offset, RegisterID base, RegisterID dst)
     {
-        m_buffer->putByte(OP_LEA);
+        m_buffer.putByte(OP_LEA);
         modRm_rm(dst, base, offset);
     }
 
     void leal_mr(int offset, RegisterID index, int scale, RegisterID dst)
     {
-        m_buffer->putByte(OP_LEA);
+        m_buffer.putByte(OP_LEA);
         modRm_rmsib(dst, X86::noBase, index, scale, offset);
     }
 
     void ret()
     {
-        m_buffer->putByte(OP_RET);
+        m_buffer.putByte(OP_RET);
     }
     
     void jmp_r(RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP5_Ev);
+        m_buffer.putByte(OP_GROUP5_Ev);
         modRm_opr(GROUP5_OP_JMPN, dst);
     }
     
     void jmp_m(int offset, RegisterID base)
     {
-        m_buffer->putByte(OP_GROUP5_Ev);
+        m_buffer.putByte(OP_GROUP5_Ev);
         modRm_opm(GROUP5_OP_JMPN, base, offset);
     }
     
     void movsd_mr(int offset, RegisterID base, XMMRegisterID dst)
     {
-        m_buffer->putByte(PRE_SSE_F2);
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_MOVSD_VsdWsd);
+        m_buffer.putByte(PRE_SSE_F2);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_MOVSD_VsdWsd);
         modRm_rm((RegisterID)dst, base, offset);
     }
 
     void movsd_rm(XMMRegisterID src, int offset, RegisterID base)
     {
-        m_buffer->putByte(PRE_SSE_F2);
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_MOVSD_WsdVsd);
+        m_buffer.putByte(PRE_SSE_F2);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_MOVSD_WsdVsd);
         modRm_rm((RegisterID)src, base, offset);
     }
 
     void movd_rr(XMMRegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(PRE_SSE_66);
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_MOVD_EdVd);
+        m_buffer.putByte(PRE_SSE_66);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_MOVD_EdVd);
         modRm_rr((RegisterID)src, dst);
     }
 
     void cvtsi2sd_rr(RegisterID src, XMMRegisterID dst)
     {
-        m_buffer->putByte(PRE_SSE_F2);
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_CVTSI2SD_VsdEd);
+        m_buffer.putByte(PRE_SSE_F2);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_CVTSI2SD_VsdEd);
         modRm_rr((RegisterID)dst, src);
     }
 
     void cvttsd2si_rr(XMMRegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(PRE_SSE_F2);
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_CVTTSD2SI_GdWsd);
+        m_buffer.putByte(PRE_SSE_F2);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_CVTTSD2SI_GdWsd);
         modRm_rr(dst, (RegisterID)src);
     }
 
     void addsd_mr(int offset, RegisterID base, XMMRegisterID dst)
     {
-        m_buffer->putByte(PRE_SSE_F2);
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_ADDSD_VsdWsd);
+        m_buffer.putByte(PRE_SSE_F2);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_ADDSD_VsdWsd);
         modRm_rm((RegisterID)dst, base, offset);
     }
 
     void subsd_mr(int offset, RegisterID base, XMMRegisterID dst)
     {
-        m_buffer->putByte(PRE_SSE_F2);
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_SUBSD_VsdWsd);
+        m_buffer.putByte(PRE_SSE_F2);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_SUBSD_VsdWsd);
         modRm_rm((RegisterID)dst, base, offset);
     }
 
     void mulsd_mr(int offset, RegisterID base, XMMRegisterID dst)
     {
-        m_buffer->putByte(PRE_SSE_F2);
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_MULSD_VsdWsd);
+        m_buffer.putByte(PRE_SSE_F2);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_MULSD_VsdWsd);
         modRm_rm((RegisterID)dst, base, offset);
     }
 
     void addsd_rr(XMMRegisterID src, XMMRegisterID dst)
     {
-        m_buffer->putByte(PRE_SSE_F2);
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_ADDSD_VsdWsd);
+        m_buffer.putByte(PRE_SSE_F2);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_ADDSD_VsdWsd);
         modRm_rr((RegisterID)dst, (RegisterID)src);
     }
 
     void subsd_rr(XMMRegisterID src, XMMRegisterID dst)
     {
-        m_buffer->putByte(PRE_SSE_F2);
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_SUBSD_VsdWsd);
+        m_buffer.putByte(PRE_SSE_F2);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_SUBSD_VsdWsd);
         modRm_rr((RegisterID)dst, (RegisterID)src);
     }
 
     void mulsd_rr(XMMRegisterID src, XMMRegisterID dst)
     {
-        m_buffer->putByte(PRE_SSE_F2);
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_MULSD_VsdWsd);
+        m_buffer.putByte(PRE_SSE_F2);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_MULSD_VsdWsd);
         modRm_rr((RegisterID)dst, (RegisterID)src);
     }
 
     void ucomis_rr(XMMRegisterID src, XMMRegisterID dst)
     {
-        m_buffer->putByte(PRE_SSE_66);
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_UCOMISD_VsdWsd);
+        m_buffer.putByte(PRE_SSE_66);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_UCOMISD_VsdWsd);
         modRm_rr((RegisterID)dst, (RegisterID)src);
     }
 
     void pextrw_irr(int whichWord, XMMRegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(PRE_SSE_66);
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_PEXTRW_GdUdIb);
+        m_buffer.putByte(PRE_SSE_66);
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_PEXTRW_GdUdIb);
         modRm_rr(dst, (RegisterID)src);
-        m_buffer->putByte(whichWord);
+        m_buffer.putByte(whichWord);
     }
 
     JmpSrc call()
     {
-        m_buffer->putByte(OP_CALL_rel32);
-        m_buffer->putInt(0); // FIXME: make this point to a global label, linked later.
-        return JmpSrc(m_buffer->size());
+        m_buffer.putByte(OP_CALL_rel32);
+        m_buffer.putInt(0); // FIXME: make this point to a global label, linked later.
+        return JmpSrc(m_buffer.size());
     }
     
     JmpSrc call(RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP5_Ev);
+        m_buffer.putByte(OP_GROUP5_Ev);
         modRm_opr(GROUP5_OP_CALLN, dst);
-        return JmpSrc(m_buffer->size());
+        return JmpSrc(m_buffer.size());
     }
 
     JmpDst label()
     {
-        return JmpDst(m_buffer->size());
+        return JmpDst(m_buffer.size());
     }
     
     JmpDst align(int alignment)
     {
-        while (!m_buffer->isAligned(alignment))
-            m_buffer->putByte(OP_HLT);
+        while (!m_buffer.isAligned(alignment))
+            m_buffer.putByte(OP_HLT);
 
         return label();
     }
 
     JmpSrc jmp()
     {
-        m_buffer->putByte(OP_JMP_rel32);
-        m_buffer->putInt(0);
-        return JmpSrc(m_buffer->size());
+        m_buffer.putByte(OP_JMP_rel32);
+        m_buffer.putInt(0);
+        return JmpSrc(m_buffer.size());
     }
     
     JmpSrc jne()
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_JNE_rel32);
-        m_buffer->putInt(0);
-        return JmpSrc(m_buffer->size());
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_JNE_rel32);
+        m_buffer.putInt(0);
+        return JmpSrc(m_buffer.size());
     }
     
     JmpSrc jnz()
@@ -915,104 +913,104 @@ public:
 
     JmpSrc je()
     {
-        m_buffer->ensureSpace(maxInstructionSize);
-        m_buffer->putByteUnchecked(OP_2BYTE_ESCAPE);
-        m_buffer->putByteUnchecked(OP2_JE_rel32);
-        m_buffer->putIntUnchecked(0);
-        return JmpSrc(m_buffer->size());
+        m_buffer.ensureSpace(maxInstructionSize);
+        m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);
+        m_buffer.putByteUnchecked(OP2_JE_rel32);
+        m_buffer.putIntUnchecked(0);
+        return JmpSrc(m_buffer.size());
     }
     
     JmpSrc jl()
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_JL_rel32);
-        m_buffer->putInt(0);
-        return JmpSrc(m_buffer->size());
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_JL_rel32);
+        m_buffer.putInt(0);
+        return JmpSrc(m_buffer.size());
     }
     
     JmpSrc jb()
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_JB_rel32);
-        m_buffer->putInt(0);
-        return JmpSrc(m_buffer->size());
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_JB_rel32);
+        m_buffer.putInt(0);
+        return JmpSrc(m_buffer.size());
     }
     
     JmpSrc jle()
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_JLE_rel32);
-        m_buffer->putInt(0);
-        return JmpSrc(m_buffer->size());
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_JLE_rel32);
+        m_buffer.putInt(0);
+        return JmpSrc(m_buffer.size());
     }
     
     JmpSrc jbe()
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_JBE_rel32);
-        m_buffer->putInt(0);
-        return JmpSrc(m_buffer->size());
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_JBE_rel32);
+        m_buffer.putInt(0);
+        return JmpSrc(m_buffer.size());
     }
     
     JmpSrc jge()
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_JGE_rel32);
-        m_buffer->putInt(0);
-        return JmpSrc(m_buffer->size());
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_JGE_rel32);
+        m_buffer.putInt(0);
+        return JmpSrc(m_buffer.size());
     }
 
     JmpSrc jg()
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_JG_rel32);
-        m_buffer->putInt(0);
-        return JmpSrc(m_buffer->size());
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_JG_rel32);
+        m_buffer.putInt(0);
+        return JmpSrc(m_buffer.size());
     }
 
     JmpSrc ja()
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_JA_rel32);
-        m_buffer->putInt(0);
-        return JmpSrc(m_buffer->size());
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_JA_rel32);
+        m_buffer.putInt(0);
+        return JmpSrc(m_buffer.size());
     }
     
     JmpSrc jae()
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_JAE_rel32);
-        m_buffer->putInt(0);
-        return JmpSrc(m_buffer->size());
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_JAE_rel32);
+        m_buffer.putInt(0);
+        return JmpSrc(m_buffer.size());
     }
     
     JmpSrc jo()
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_JO_rel32);
-        m_buffer->putInt(0);
-        return JmpSrc(m_buffer->size());
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_JO_rel32);
+        m_buffer.putInt(0);
+        return JmpSrc(m_buffer.size());
     }
 
     JmpSrc jp()
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_JP_rel32);
-        m_buffer->putInt(0);
-        return JmpSrc(m_buffer->size());
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_JP_rel32);
+        m_buffer.putInt(0);
+        return JmpSrc(m_buffer.size());
     }
     
     JmpSrc js()
     {
-        m_buffer->putByte(OP_2BYTE_ESCAPE);
-        m_buffer->putByte(OP2_JS_rel32);
-        m_buffer->putInt(0);
-        return JmpSrc(m_buffer->size());
+        m_buffer.putByte(OP_2BYTE_ESCAPE);
+        m_buffer.putByte(OP2_JS_rel32);
+        m_buffer.putInt(0);
+        return JmpSrc(m_buffer.size());
     }
     
     void predictNotTaken()
     {
-        m_buffer->putByte(PRE_PREDICT_BRANCH_NOT_TAKEN);
+        m_buffer.putByte(PRE_PREDICT_BRANCH_NOT_TAKEN);
     }
     
     void link(JmpSrc from, JmpDst to)
@@ -1020,7 +1018,7 @@ public:
         ASSERT(to.m_offset != -1);
         ASSERT(from.m_offset != -1);
         
-        reinterpret_cast<int*>(reinterpret_cast<ptrdiff_t>(m_buffer->data()) + from.m_offset)[-1] = to.m_offset - from.m_offset;
+        reinterpret_cast<int*>(reinterpret_cast<ptrdiff_t>(m_buffer.data()) + from.m_offset)[-1] = to.m_offset - from.m_offset;
     }
     
     static void linkAbsoluteAddress(void* code, JmpDst useOffset, JmpDst address)
@@ -1080,7 +1078,7 @@ public:
     
     void* executableCopy()
     {
-        void* copy = m_buffer->executableCopy();
+        void* copy = m_buffer.executableCopy();
         ASSERT(copy);
         return copy;
     }
@@ -1110,58 +1108,58 @@ public:
 private:
     void modRm_rr(RegisterID reg, RegisterID rm)
     {
-        m_buffer->ensureSpace(maxInstructionSize);
+        m_buffer.ensureSpace(maxInstructionSize);
         modRm_rr_Unchecked(reg, rm);
     }
 
     void modRm_rr_Unchecked(RegisterID reg, RegisterID rm)
     {
-        m_buffer->putByteUnchecked(MODRM(3, reg, rm));
+        m_buffer.putByteUnchecked(MODRM(3, reg, rm));
     }
 
 #if !PLATFORM(X86_64)
     void modRm_rm(RegisterID reg, void* addr)
     {
-        m_buffer->putByte(MODRM(0, reg, X86::noBase));
-        m_buffer->putInt((int)addr);
+        m_buffer.putByte(MODRM(0, reg, X86::noBase));
+        m_buffer.putInt((int)addr);
     }
 #endif
 
     void modRm_rm(RegisterID reg, RegisterID base)
     {
         if (base == X86::esp) {
-            m_buffer->putByte(MODRM(0, reg, X86::hasSib));
-            m_buffer->putByte(SIB(0, X86::noScale, X86::esp));
+            m_buffer.putByte(MODRM(0, reg, X86::hasSib));
+            m_buffer.putByte(SIB(0, X86::noScale, X86::esp));
         } else
-            m_buffer->putByte(MODRM(0, reg, base));
+            m_buffer.putByte(MODRM(0, reg, base));
     }
 
     void modRm_rm_Unchecked(RegisterID reg, RegisterID base, int offset)
     {
         if (base == X86::esp) {
             if (CAN_SIGN_EXTEND_8_32(offset)) {
-                m_buffer->putByteUnchecked(MODRM(1, reg, X86::hasSib));
-                m_buffer->putByteUnchecked(SIB(0, X86::noScale, X86::esp));
-                m_buffer->putByteUnchecked(offset);
+                m_buffer.putByteUnchecked(MODRM(1, reg, X86::hasSib));
+                m_buffer.putByteUnchecked(SIB(0, X86::noScale, X86::esp));
+                m_buffer.putByteUnchecked(offset);
             } else {
-                m_buffer->putByteUnchecked(MODRM(2, reg, X86::hasSib));
-                m_buffer->putByteUnchecked(SIB(0, X86::noScale, X86::esp));
-                m_buffer->putIntUnchecked(offset);
+                m_buffer.putByteUnchecked(MODRM(2, reg, X86::hasSib));
+                m_buffer.putByteUnchecked(SIB(0, X86::noScale, X86::esp));
+                m_buffer.putIntUnchecked(offset);
             }
         } else {
             if (CAN_SIGN_EXTEND_8_32(offset)) {
-                m_buffer->putByteUnchecked(MODRM(1, reg, base));
-                m_buffer->putByteUnchecked(offset);
+                m_buffer.putByteUnchecked(MODRM(1, reg, base));
+                m_buffer.putByteUnchecked(offset);
             } else {
-                m_buffer->putByteUnchecked(MODRM(2, reg, base));
-                m_buffer->putIntUnchecked(offset);
+                m_buffer.putByteUnchecked(MODRM(2, reg, base));
+                m_buffer.putIntUnchecked(offset);
             }
         }
     }
 
     void modRm_rm(RegisterID reg, RegisterID base, int offset)
     {
-        m_buffer->ensureSpace(maxInstructionSize);
+        m_buffer.ensureSpace(maxInstructionSize);
         modRm_rm_Unchecked(reg, base, offset);
     }
 
@@ -1171,8 +1169,8 @@ private:
         while (scale >>= 1)
             shift++;
     
-        m_buffer->putByte(MODRM(0, reg, X86::hasSib));
-        m_buffer->putByte(SIB(shift, index, base));
+        m_buffer.putByte(MODRM(0, reg, X86::hasSib));
+        m_buffer.putByte(SIB(shift, index, base));
     }
 
     void modRm_rmsib(RegisterID reg, RegisterID base, RegisterID index, int scale, int offset)
@@ -1182,19 +1180,19 @@ private:
             shift++;
     
         if (CAN_SIGN_EXTEND_8_32(offset)) {
-            m_buffer->putByte(MODRM(1, reg, X86::hasSib));
-            m_buffer->putByte(SIB(shift, index, base));
-            m_buffer->putByte(offset);
+            m_buffer.putByte(MODRM(1, reg, X86::hasSib));
+            m_buffer.putByte(SIB(shift, index, base));
+            m_buffer.putByte(offset);
         } else {
-            m_buffer->putByte(MODRM(2, reg, X86::hasSib));
-            m_buffer->putByte(SIB(shift, index, base));
-            m_buffer->putInt(offset);
+            m_buffer.putByte(MODRM(2, reg, X86::hasSib));
+            m_buffer.putByte(SIB(shift, index, base));
+            m_buffer.putInt(offset);
         }
     }
 
     void modRm_opr(OpcodeID opcodeID, RegisterID rm)
     {
-        m_buffer->ensureSpace(maxInstructionSize);
+        m_buffer.ensureSpace(maxInstructionSize);
         modRm_opr_Unchecked(opcodeID, rm);
     }
 
@@ -1230,7 +1228,7 @@ private:
         modRm_rmsib(static_cast<RegisterID>(opcodeID), base, index, scale, offset);
     }
 
-    AssemblerBuffer* m_buffer;
+    AssemblerBuffer m_buffer;
 };
 
 } // namespace JSC
index 1def792..f70a471 100644 (file)
@@ -611,9 +611,6 @@ Interpreter::Interpreter()
     , m_ctiVirtualCallLink(0)
     , m_ctiVirtualCall(0)
 #endif
-#if ENABLE(ASSEMBLER)
-    , m_assemblerBuffer(new AssemblerBuffer(1024 * 1024))
-#endif
     , m_reentryDepth(0)
     , m_timeoutTime(0)
     , m_timeAtLastCheckTimeout(0)
index 0b4af6f..c2ce9c2 100644 (file)
@@ -279,10 +279,6 @@ namespace JSC {
         
 #endif // ENABLE(JIT)
 
-#if ENABLE(ASSEMBLER)
-        AssemblerBuffer* assemblerBuffer() const { return m_assemblerBuffer.get(); }
-#endif
-
         // Default number of ticks before a timeout check should be done.
         static const int initialTickCountThreshold = 1024;
 
@@ -344,10 +340,6 @@ namespace JSC {
         void* m_ctiVirtualCall;
 #endif
 
-#if ENABLE(ASSEMBLER)
-        OwnPtr<AssemblerBuffer> m_assemblerBuffer;
-#endif
-
         int m_reentryDepth;
         unsigned m_timeoutTime;
         unsigned m_timeAtLastCheckTimeout;
index 64454f8..6738c8a 100644 (file)
@@ -589,8 +589,7 @@ ALWAYS_INLINE void JIT::emitTagAsBoolImmediate(RegisterID reg)
 }
 
 JIT::JIT(JSGlobalData* globalData, CodeBlock* codeBlock)
-    : m_assembler(globalData->interpreter->assemblerBuffer())
-    , m_interpreter(globalData->interpreter)
+    : m_interpreter(globalData->interpreter)
     , m_globalData(globalData)
     , m_codeBlock(codeBlock)
     , m_labels(codeBlock ? codeBlock->instructions.size() : 0)
index d57b432..323627e 100644 (file)
@@ -312,7 +312,7 @@ RegisterID* StringNode::emitBytecode(BytecodeGenerator& generator, RegisterID* d
 
 RegisterID* RegExpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
-    RefPtr<RegExp> regExp = RegExp::create(generator.globalData(), m_pattern, m_flags);
+    RefPtr<RegExp> regExp = RegExp::create(m_pattern, m_flags);
     if (!regExp->isValid())
         return emitThrowError(generator, SyntaxError, ("Invalid regular expression: " + UString(regExp->errorMessage())).UTF8String().c_str());
     if (dst == generator.ignoredResult())
index b8a8906..4ccbe4a 100644 (file)
@@ -37,7 +37,7 @@ namespace JSC {
 using namespace WREC;
 #endif
 
-inline RegExp::RegExp(JSGlobalData* globalData, const UString& pattern)
+inline RegExp::RegExp(const UString& pattern)
     : m_pattern(pattern)
     , m_flagBits(0)
     , m_regExp(0)
@@ -45,23 +45,21 @@ inline RegExp::RegExp(JSGlobalData* globalData, const UString& pattern)
     , m_numSubpatterns(0)
 {
 #if ENABLE(WREC)
-    m_wrecFunction = Generator::compileRegExp(globalData->interpreter, pattern, &m_numSubpatterns, &m_constructionError);
+    m_wrecFunction = Generator::compileRegExp(pattern, &m_numSubpatterns, &m_constructionError);
     if (m_wrecFunction)
         return;
     // Fall through to non-WREC case.
-#else
-    UNUSED_PARAM(globalData);
 #endif
     m_regExp = jsRegExpCompile(reinterpret_cast<const UChar*>(pattern.data()), pattern.size(),
         JSRegExpDoNotIgnoreCase, JSRegExpSingleLine, &m_numSubpatterns, &m_constructionError);
 }
 
-PassRefPtr<RegExp> RegExp::create(JSGlobalData* globalData, const UString& pattern)
+PassRefPtr<RegExp> RegExp::create(const UString& pattern)
 {
-    return adoptRef(new RegExp(globalData, pattern));
+    return adoptRef(new RegExp(pattern));
 }
 
-inline RegExp::RegExp(JSGlobalData* globalData, const UString& pattern, const UString& flags)
+inline RegExp::RegExp(const UString& pattern, const UString& flags)
     : m_pattern(pattern)
     , m_flags(flags)
     , m_flagBits(0)
@@ -88,20 +86,18 @@ inline RegExp::RegExp(JSGlobalData* globalData, const UString& pattern, const US
     }
 
 #if ENABLE(WREC)
-    m_wrecFunction = Generator::compileRegExp(globalData->interpreter, pattern, &m_numSubpatterns, &m_constructionError, (m_flagBits & IgnoreCase), (m_flagBits & Multiline));
+    m_wrecFunction = Generator::compileRegExp(pattern, &m_numSubpatterns, &m_constructionError, (m_flagBits & IgnoreCase), (m_flagBits & Multiline));
     if (m_wrecFunction)
         return;
     // Fall through to non-WREC case.
-#else
-    UNUSED_PARAM(globalData);
 #endif
     m_regExp = jsRegExpCompile(reinterpret_cast<const UChar*>(pattern.data()), pattern.size(),
         ignoreCaseOption, multilineOption, &m_numSubpatterns, &m_constructionError);
 }
 
-PassRefPtr<RegExp> RegExp::create(JSGlobalData* globalData, const UString& pattern, const UString& flags)
+PassRefPtr<RegExp> RegExp::create(const UString& pattern, const UString& flags)
 {
-    return adoptRef(new RegExp(globalData, pattern, flags));
+    return adoptRef(new RegExp(pattern, flags));
 }
 
 RegExp::~RegExp()
index 2255e67..bc183d5 100644 (file)
@@ -34,8 +34,8 @@ namespace JSC {
 
     class RegExp : public RefCounted<RegExp> {
     public:
-        static PassRefPtr<RegExp> create(JSGlobalData*, const UString& pattern);
-        static PassRefPtr<RegExp> create(JSGlobalData*, const UString& pattern, const UString& flags);
+        static PassRefPtr<RegExp> create(const UString& pattern);
+        static PassRefPtr<RegExp> create(const UString& pattern, const UString& flags);
         ~RegExp();
 
         bool global() const { return m_flagBits & Global; }
@@ -52,8 +52,8 @@ namespace JSC {
         unsigned numSubpatterns() const { return m_numSubpatterns; }
 
     private:
-        RegExp(JSGlobalData*, const UString& pattern);
-        RegExp(JSGlobalData*, const UString& pattern, const UString& flags);
+        RegExp(const UString& pattern);
+        RegExp(const UString& pattern, const UString& flags);
 
         void compile();
 
index fb745e5..d15729a 100644 (file)
@@ -331,7 +331,7 @@ JSObject* constructRegExp(ExecState* exec, const ArgList& args)
     UString pattern = arg0->isUndefined() ? UString("") : arg0->toString(exec);
     UString flags = arg1->isUndefined() ? UString("") : arg1->toString(exec);
 
-    RefPtr<RegExp> regExp = RegExp::create(&exec->globalData(), pattern, flags);
+    RefPtr<RegExp> regExp = RegExp::create(pattern, flags);
     if (!regExp->isValid())
         return throwError(exec, SyntaxError, UString("Invalid regular expression: ").append(regExp->errorMessage()));
     return new (exec) RegExpObject(exec->lexicalGlobalObject()->regExpStructure(), regExp.release());
index e932244..f4d5b47 100644 (file)
@@ -85,7 +85,7 @@ JSValue* regExpProtoFuncCompile(ExecState* exec, JSObject*, JSValue* thisValue,
     } else {
         UString pattern = args.isEmpty() ? UString("") : arg0->toString(exec);
         UString flags = arg1->isUndefined() ? UString("") : arg1->toString(exec);
-        regExp = RegExp::create(&exec->globalData(), pattern, flags);
+        regExp = RegExp::create(pattern, flags);
     }
 
     if (!regExp->isValid())
index f9bd0b8..601fbd0 100644 (file)
@@ -412,7 +412,7 @@ JSValue* stringProtoFuncMatch(ExecState* exec, JSObject*, JSValue* thisValue, co
          *  If regexp is not an object whose [[Class]] property is "RegExp", it is
          *  replaced with the result of the expression new RegExp(regexp).
          */
-        reg = RegExp::create(&exec->globalData(), a0->toString(exec));
+        reg = RegExp::create(a0->toString(exec));
     }
     RegExpConstructor* regExpConstructor = exec->lexicalGlobalObject()->regExpConstructor();
     int pos;
@@ -462,7 +462,7 @@ JSValue* stringProtoFuncSearch(ExecState* exec, JSObject*, JSValue* thisValue, c
          *  If regexp is not an object whose [[Class]] property is "RegExp", it is
          *  replaced with the result of the expression new RegExp(regexp).
          */
-        reg = RegExp::create(&exec->globalData(), a0->toString(exec));
+        reg = RegExp::create(a0->toString(exec));
     }
     RegExpConstructor* regExpConstructor = exec->lexicalGlobalObject()->regExpConstructor();
     int pos;
index 4f2b5f4..fb106e0 100644 (file)
@@ -41,14 +41,14 @@ namespace JSC { namespace WREC {
 // This limit comes from the limit set in PCRE
 static const int MaxPatternSize = (1 << 16);
 
-CompiledRegExp Generator::compileRegExp(Interpreter* interpreter, const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase, bool multiline)
+CompiledRegExp Generator::compileRegExp(const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase, bool multiline)
 {
     if (pattern.size() > MaxPatternSize) {
         *error_ptr = "Regular expression too large.";
         return 0;
     }
 
-    Parser parser(pattern, ignoreCase, multiline, interpreter->assemblerBuffer());
+    Parser parser(pattern, ignoreCase, multiline);
     Generator& generator = parser.generator();
     MacroAssembler::JumpList failures;
 
index 18fa8fc..f1def43 100644 (file)
@@ -49,11 +49,10 @@ namespace JSC { namespace WREC {
         using MacroAssembler::JumpList;
         using MacroAssembler::Label;
 
-        static CompiledRegExp compileRegExp(Interpreter*, const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase = false, bool multiline = false);
-    
-        Generator(Parser& parser, AssemblerBuffer* assemblerBuffer)
-            : MacroAssembler(assemblerBuffer)
-            , m_parser(parser)
+        static CompiledRegExp compileRegExp(const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase = false, bool multiline = false);
+
+        Generator(Parser& parser)
+            : m_parser(parser)
         {
         }
 
index 947fd51..84a5da9 100644 (file)
@@ -55,8 +55,8 @@ namespace JSC { namespace WREC {
             UnsupportedParentheses,
         };
 
-        Parser(const UString& pattern, bool ignoreCase, bool multiline, AssemblerBuffer* assemblerBuffer)
-            : m_generator(*this, assemblerBuffer)
+        Parser(const UString& pattern, bool ignoreCase, bool multiline)
+            : m_generator(*this)
             , m_data(pattern.data())
             , m_size(pattern.size())
             , m_ignoreCase(ignoreCase)