Changeset 38975 in webkit for trunk/JavaScriptCore

Timestamp:

Dec 3, 2008, 4:10:53 PM (16 years ago)

Author:

[email protected]

Message:

2008-12-03 Sam Weinig <​[email protected]>

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):

Location:

trunk/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• assembler/AssemblerBuffer.h (modified) (4 diffs)
• assembler/MacroAssembler.h (modified) (1 diff)
• assembler/X86Assembler.h (modified) (83 diffs)
• interpreter/Interpreter.cpp (modified) (1 diff)
• interpreter/Interpreter.h (modified) (2 diffs)
• jit/JIT.cpp (modified) (1 diff)
• parser/Nodes.cpp (modified) (1 diff)
• runtime/RegExp.cpp (modified) (5 diffs)
• runtime/RegExp.h (modified) (2 diffs)
• runtime/RegExpConstructor.cpp (modified) (1 diff)
• runtime/RegExpPrototype.cpp (modified) (1 diff)
• runtime/StringPrototype.cpp (modified) (2 diffs)
• wrec/WREC.cpp (modified) (2 diffs)
• wrec/WRECGenerator.h (modified) (1 diff)
• wrec/WRECParser.h (modified) (1 diff)

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2008-12-03  Sam Weinig  <[email protected]>
+
+        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  <[email protected]>
 

trunk/JavaScriptCore/assembler/AssemblerBuffer.h

@@ -38 +38 @@
 
     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)
         {
@@ -48 +49 @@
         ~AssemblerBuffer()
         {
-            fastFree(m_buffer);
+            if (m_buffer != m_inlineBuffer)
+                fastFree(m_buffer);
         }
 
@@ -113 +115 @@
         }
 
-        AssemblerBuffer* reset()
-        {
-            m_size = 0;
-            return this;
-        }
-
         void* executableCopy()
         {
@@ -136 +132 @@
         {
             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;

trunk/JavaScriptCore/assembler/MacroAssembler.h

@@ -50 +50 @@
     };
 
-    MacroAssembler(AssemblerBuffer* assemblerBuffer)
-        : m_assembler(assemblerBuffer)
+    MacroAssembler()
     {
     }

trunk/JavaScriptCore/assembler/X86Assembler.h

@@ -206 +206 @@
     static const int maxInstructionSize = 16;
 
-    X86Assembler(AssemblerBuffer* m_buffer)
-        : m_buffer(m_buffer)
-    {
-        m_buffer->reset();
+    X86Assembler()
+    {
     }
 
     void int3()
     {
-        m_buffer->putByte(OP_INT3);
+        m_buffer.putByte(OP_INT3);
     }
     
@@ -220 +218 @@
     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);
     }
@@ -241 +239 @@
     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);
     }
@@ -259 +257 @@
     void movl_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_MOV_EvGv);
+        m_buffer.putByte(OP_MOV_EvGv);
         modRm_rr(src, dst);
     }
@@ -266 +264 @@
     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);
     }
@@ -274 +272 @@
     void addl_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_ADD_EvGv);
+        m_buffer.putByte(OP_ADD_EvGv);
         modRm_rr(src, dst);
     }
@@ -281 +279 @@
     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
@@ -289 +287 @@
     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);
     }
 
@@ -304 +302 @@
     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
@@ -321 +319 @@
     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);
     }
@@ -327 +325 @@
     void andl_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_AND_EvGv);
+        m_buffer.putByte(OP_AND_EvGv);
         modRm_rr(src, dst);
     }
@@ -333 +331 @@
     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);
     }
@@ -353 +351 @@
     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);
     }
@@ -359 +357 @@
     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);
     }
@@ -365 +363 @@
     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);
     }
 
@@ -387 +385 @@
     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
@@ -395 +393 @@
     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);
     }
@@ -409 +407 @@
     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);
     }
@@ -416 +414 @@
     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));
     }
 
@@ -428 +426 @@
     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));
     }
 
@@ -440 +438 @@
     void orl_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_OR_EvGv);
+        m_buffer.putByte(OP_OR_EvGv);
         modRm_rr(src, dst);
     }
@@ -446 +444 @@
     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);
     }
@@ -452 +450 @@
     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);
     }
 
@@ -466 +464 @@
     void subl_rr(RegisterID src, RegisterID dst)
     {
-        m_buffer->putByte(OP_SUB_EvGv);
+        m_buffer.putByte(OP_SUB_EvGv);
         modRm_rr(src, dst);
     }
@@ -472 +470 @@
     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);
     }
     
@@ -480 +478 @@
     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
@@ -488 +486 @@
     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);
     }
@@ -501 +499 @@
     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);
     }
@@ -529 +527 @@
     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);
     }
@@ -543 +541 @@
     {
         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);
         }
     }
@@ -554 +552 @@
     void sarl_CLr(RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP2_EvCL);
+        m_buffer.putByte(OP_GROUP2_EvCL);
         modRm_opr(GROUP2_OP_SAR, dst);
     }
@@ -561 +559 @@
     {
         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);
         }
     }
@@ -572 +570 @@
     void shll_CLr(RegisterID dst)
     {
-        m_buffer->putByte(OP_GROUP2_EvCL);
+        m_buffer.putByte(OP_GROUP2_EvCL);
         modRm_opr(GROUP2_OP_SHL, dst);
     }
@@ -578 +576 @@
     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);
     }
@@ -585 +583 @@
     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);
     }
@@ -598 +596 @@
     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);
     }
@@ -609 +607 @@
     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);
     }
@@ -617 +615 @@
     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);
     }
@@ -624 +622 @@
     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);
     }
@@ -634 +632 @@
     void movl_mr(void* addr, RegisterID dst)
     {
-        m_buffer->putByte(OP_MOV_GvEv);
+        m_buffer.putByte(OP_MOV_GvEv);
         modRm_rm(dst, addr);
     }
@@ -641 +639 @@
     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);
     }
@@ -647 +645 @@
     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);
     }
@@ -654 +652 @@
     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);
     }
@@ -661 +659 @@
     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);
     }
@@ -668 +666 @@
     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);
     }
@@ -675 +673 @@
     void movl_rm(RegisterID src, RegisterID base)
     {
-        m_buffer->putByte(OP_MOV_EvGv);
+        m_buffer.putByte(OP_MOV_EvGv);
         modRm_rm(src, base);
     }
@@ -681 +679 @@
     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);
     }
@@ -689 +687 @@
     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);
     }
@@ -696 +694 @@
     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);
     }
@@ -705 +703 @@
     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);
     }
@@ -711 +709 @@
     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);
     }
 
@@ -727 +725 @@
     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
@@ -735 +733 @@
     void leal_mr(int offset, RegisterID base, RegisterID dst)
     {
-        m_buffer->putByte(OP_LEA);
+        m_buffer.putByte(OP_LEA);
         modRm_rm(dst, base, offset);
     }
@@ -741 +739 @@
     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);
     }
@@ -747 +745 @@
     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);
     }
@@ -758 +756 @@
     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);
     }
@@ -764 +762 @@
     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);
     }
@@ -772 +770 @@
     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);
     }
@@ -780 +778 @@
     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);
     }
@@ -788 +786 @@
     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);
     }
@@ -796 +794 @@
     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);
     }
@@ -804 +802 @@
     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);
     }
@@ -812 +810 @@
     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);
     }
@@ -820 +818 @@
     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);
     }
@@ -828 +826 @@
     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);
     }
@@ -836 +834 @@
     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);
     }
@@ -844 +842 @@
     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);
     }
@@ -852 +850 @@
     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);
     }
@@ -860 +858 @@
     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();
@@ -896 +894 @@
     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());
     }
     
@@ -916 +914 @@
     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);
     }
     
@@ -1021 +1019 @@
         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;
     }
     
@@ -1081 +1079 @@
     void* executableCopy()
     {
-        void* copy = m_buffer->executableCopy();
+        void* copy = m_buffer.executableCopy();
         ASSERT(copy);
         return copy;
@@ -1111 +1109 @@
     void modRm_rr(RegisterID reg, RegisterID rm)
     {
-        m_buffer->ensureSpace(maxInstructionSize);
+        m_buffer.ensureSpace(maxInstructionSize);
         modRm_rr_Unchecked(reg, rm);
     }
@@ -1117 +1115 @@
     void modRm_rr_Unchecked(RegisterID reg, RegisterID rm)
     {
-        m_buffer->putByteUnchecked(MODRM(3, reg, rm));
+        m_buffer.putByteUnchecked(MODRM(3, reg, rm));
     }
 
@@ -1123 +1121 @@
     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
@@ -1131 +1129 @@
     {
         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));
     }
 
@@ -1141 +1139 @@
         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);
             }
         }
@@ -1162 +1160 @@
     void modRm_rm(RegisterID reg, RegisterID base, int offset)
     {
-        m_buffer->ensureSpace(maxInstructionSize);
+        m_buffer.ensureSpace(maxInstructionSize);
         modRm_rm_Unchecked(reg, base, offset);
     }
@@ -1172 +1170 @@
             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));
     }
 
@@ -1183 +1181 @@
     
         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);
         }
     }
@@ -1195 +1193 @@
     void modRm_opr(OpcodeID opcodeID, RegisterID rm)
     {
-        m_buffer->ensureSpace(maxInstructionSize);
+        m_buffer.ensureSpace(maxInstructionSize);
         modRm_opr_Unchecked(opcodeID, rm);
     }
@@ -1231 +1229 @@
     }
 
-    AssemblerBuffer* m_buffer;
+    AssemblerBuffer m_buffer;
 };
 

trunk/JavaScriptCore/interpreter/Interpreter.cpp

@@ -611 +611 @@
     , m_ctiVirtualCallLink(0)
     , m_ctiVirtualCall(0)
-#endif
-#if ENABLE(ASSEMBLER)
-    , m_assemblerBuffer(new AssemblerBuffer(1024 * 1024))
 #endif
     , m_reentryDepth(0)

trunk/JavaScriptCore/interpreter/Interpreter.h

@@ -280 +280 @@
 #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;
@@ -345 +341 @@
 #endif
 
-#if ENABLE(ASSEMBLER)
-        OwnPtr<AssemblerBuffer> m_assemblerBuffer;
-#endif
-
         int m_reentryDepth;
         unsigned m_timeoutTime;

trunk/JavaScriptCore/jit/JIT.cpp

@@ -590 +590 @@
 
 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)

trunk/JavaScriptCore/parser/Nodes.cpp

@@ -313 +313 @@
 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());

trunk/JavaScriptCore/runtime/RegExp.cpp

@@ -38 +38 @@
 #endif
 
-inline RegExp::RegExp(JSGlobalData* globalData, const UString& pattern)
+inline RegExp::RegExp(const UString& pattern)
     : m_pattern(pattern)
     , m_flagBits(0)
@@ -46 +46 @@
 {
 #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(),
@@ -57 +55 @@
 }
 
-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)
@@ -89 +87 @@
 
 #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(),
@@ -100 +96 @@
 }
 
-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));
 }
 

trunk/JavaScriptCore/runtime/RegExp.h

@@ -35 +35 @@
     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();
 
@@ -53 +53 @@
 
     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();

trunk/JavaScriptCore/runtime/RegExpConstructor.cpp

@@ -332 +332 @@
     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()));

trunk/JavaScriptCore/runtime/RegExpPrototype.cpp

@@ -86 +86 @@
         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);
     }
 

trunk/JavaScriptCore/runtime/StringPrototype.cpp

@@ -413 +413 @@
          *  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();
@@ -463 +463 @@
          *  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();

trunk/JavaScriptCore/wrec/WREC.cpp

@@ -42 +42 @@
 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) {
@@ -49 +49 @@
     }
 
-    Parser parser(pattern, ignoreCase, multiline, interpreter->assemblerBuffer());
+    Parser parser(pattern, ignoreCase, multiline);
     Generator& generator = parser.generator();
     MacroAssembler::JumpList failures;

trunk/JavaScriptCore/wrec/WRECGenerator.h

@@ -50 +50 @@
         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)
         {
         }

trunk/JavaScriptCore/wrec/WRECParser.h

@@ -56 +56 @@
         };
 
-        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())