Changeset 39284 in webkit for trunk/JavaScriptCore/assembler/MacroAssembler.h

Timestamp:

Dec 13, 2008, 3:58:58 PM (16 years ago)

Author:

[email protected]

Message:

2008-12-13 Gavin Barraclough <​[email protected]>

Reviewed by Cameron Zwarich.

Port the remainder of the JIT, bar calling convention related code, and code
implementing optimizations which can be disabled, to use the MacroAssembler.

• assembler/MacroAssembler.h: (JSC::MacroAssembler::DataLabelPtr::DataLabelPtr): (JSC::MacroAssembler::RepatchBuffer::RepatchBuffer): (JSC::MacroAssembler::RepatchBuffer::link): (JSC::MacroAssembler::RepatchBuffer::addressOf): (JSC::MacroAssembler::RepatchBuffer::setPtr): (JSC::MacroAssembler::addPtr): (JSC::MacroAssembler::lshift32): (JSC::MacroAssembler::mod32): (JSC::MacroAssembler::rshift32): (JSC::MacroAssembler::storePtrWithRepatch): (JSC::MacroAssembler::jnzPtr): (JSC::MacroAssembler::jzPtr): (JSC::MacroAssembler::jump): (JSC::MacroAssembler::label):
• assembler/X86Assembler.h: (JSC::X86Assembler::): (JSC::X86Assembler::xchgl_rr): (JSC::X86Assembler::jmp_m): (JSC::X86Assembler::repatchAddress): (JSC::X86Assembler::getRelocatedAddress):
• bytecode/CodeBlock.cpp: (JSC::CodeBlock::CodeBlock):
• bytecode/CodeBlock.h: (JSC::JITCodeRef::JITCodeRef): (JSC::CodeBlock::setJITCode): (JSC::CodeBlock::jitCode): (JSC::CodeBlock::executablePool):
• jit/JIT.cpp: (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompileLinkPass): (JSC::JIT::privateCompile): (JSC::JIT::privateCompileCTIMachineTrampolines):
• jit/JIT.h: (JSC::CallRecord::CallRecord): (JSC::JumpTable::JumpTable): (JSC::JIT::emitCTICall): (JSC::JIT::JSRInfo::JSRInfo):
• jit/JITArithmetic.cpp:
• jit/JITCall.cpp:
• jit/JITInlineMethods.h: (JSC::JIT::emitNakedCall): (JSC::JIT::emitCTICall_internal): (JSC::JIT::checkStructure): (JSC::JIT::emitFastArithDeTagImmediateJumpIfZero): (JSC::JIT::addSlowCase): (JSC::JIT::addJump): (JSC::JIT::emitJumpSlowToHot):
• jit/JITPropertyAccess.cpp: (JSC::JIT::privateCompileGetByIdChainList): (JSC::JIT::privateCompileGetByIdChain):

File:

• trunk/JavaScriptCore/assembler/MacroAssembler.h (modified) (16 diffs)

trunk/JavaScriptCore/assembler/MacroAssembler.h

@@ -66 +66 @@
     }
 
+
     // Address:
     //
@@ -137 +138 @@
     };
 
+
     class Jump;
+    class RepatchBuffer;
+
+    // DataLabelPtr:
+    //
+    // A DataLabelPtr is used to refer to a location in the code containing a pointer to be
+    // repatched after the code has been generated.
+    class DataLabelPtr {
+        friend class MacroAssembler;
+
+    public:
+        DataLabelPtr()
+        {
+        }
+
+        DataLabelPtr(MacroAssembler* masm)
+            : m_label(masm->m_assembler.label())
+        {
+        }
+
+    private:
+        X86Assembler::JmpDst m_label;
+    };
 
     // Label:
@@ -146 +170 @@
         friend class Jump;
         friend class MacroAssembler;
+        friend class RepatchBuffer;
 
     public:
@@ -160 +185 @@
         X86Assembler::JmpDst m_label;
     };
-    
+
+
     // Jump:
     //
@@ -177 +203 @@
     // Jumps may also be linked to a Label.
     class Jump {
+        friend class RepatchBuffer;
+        friend class MacroAssembler;
+
     public:
         Jump()
@@ -182 +211 @@
         }
         
+        // FIXME: transitionary method, while we replace JmpSrces with Jumps.
         Jump(X86Assembler::JmpSrc jmp)
             : m_jmp(jmp)
@@ -242 +272 @@
         Vector<Jump> m_jumps;
     };
+
+
+    // RepatchBuffer:
+    //
+    // This class assists in linking code generated by the macro assembler, once code generation
+    // has been completed, and the code has been copied to is final location in memory.  At this
+    // time pointers to labels within the code may be resolved, and relative offsets to external
+    // addresses may be fixed.
+    //
+    // Specifically:
+    //   * Jump objects may be linked to external targets,
+    //   * The address of Jump objects may taken, such that it can later be relinked.
+    //   * The return address of a Jump object representing a call may be acquired.
+    //   * The address of a Label pointing into the code may be resolved.
+    //   * The value referenced by a DataLabel may be fixed.
+    //
+    // FIXME: distinguish between Calls & Jumps (make a specific call to obtain the return
+    // address of calls, as opposed to a point that can be used to later relink a Jump -
+    // possibly wrap the later up in an object that can do just that).
+    class RepatchBuffer {
+    public:
+        RepatchBuffer(void* code)
+            : m_code(code)
+        {
+        }
+
+        void link(Jump jump, void* target)
+        {
+            X86Assembler::link(m_code, jump.m_jmp, target);
+        }
+        
+        void* addressOf(Jump jump)
+        {
+            return X86Assembler::getRelocatedAddress(m_code, jump.m_jmp);
+        }
+        
+        void* addressOf(Label label)
+        {
+            return X86Assembler::getRelocatedAddress(m_code, label.m_label);
+        }
+
+        void setPtr(DataLabelPtr label, void* value)
+        {
+            X86Assembler::repatchAddress(m_code, label.m_label, value);
+        }
+
+    private:
+        void* m_code;
+    };
+ 
 
     // Imm32:
@@ -258 +338 @@
     };
 
-
     // ImmPtr:
     //
@@ -281 +360 @@
     // object).
 
-    void addPtr(Imm32 imm, RegisterID dest)
+    void addPtr(Imm32 imm, RegisterID srcDest)
     {
 #if PLATFORM(X86_64)
         if (CAN_SIGN_EXTEND_8_32(imm.m_value))
-            m_assembler.addq_i8r(imm.m_value, dest);
-        else
-            m_assembler.addq_i32r(imm.m_value, dest);
+            m_assembler.addq_i8r(imm.m_value, srcDest);
+        else
+            m_assembler.addq_i32r(imm.m_value, srcDest);
 #else
         if (CAN_SIGN_EXTEND_8_32(imm.m_value))
-            m_assembler.addl_i8r(imm.m_value, dest);
-        else
-            m_assembler.addl_i32r(imm.m_value, dest);
-#endif
+            m_assembler.addl_i8r(imm.m_value, srcDest);
+        else
+            m_assembler.addl_i32r(imm.m_value, srcDest);
+#endif
+    }
+
+
+    void addPtr(Imm32 imm, RegisterID src, RegisterID dest)
+    {
+        m_assembler.leal_mr(imm.m_value, src, dest);
     }
 
@@ -335 +420 @@
     }
     
+    void lshift32(RegisterID shift_amount, RegisterID dest)
+    {
+        // On x86 we can only shift by ecx; if asked to shift by another register we'll
+        // need rejig the shift amount into ecx first, and restore the registers afterwards.
+        if (shift_amount != X86::ecx) {
+            m_assembler.xchgl_rr(shift_amount, X86::ecx);
+
+            // E.g. transform "shll %eax, %eax" -> "xchgl %eax, %ecx; shll %ecx, %ecx; xchgl %eax, %ecx"
+            if (dest == shift_amount)
+                m_assembler.shll_CLr(X86::ecx);
+            // E.g. transform "shll %eax, %ecx" -> "xchgl %eax, %ecx; shll %ecx, %eax; xchgl %eax, %ecx"
+            else if (dest == X86::ecx)
+                m_assembler.shll_CLr(shift_amount);
+            // E.g. transform "shll %eax, %ebx" -> "xchgl %eax, %ecx; shll %ecx, %ebx; xchgl %eax, %ecx"
+            else
+                m_assembler.shll_CLr(dest);
+        
+            m_assembler.xchgl_rr(shift_amount, X86::ecx);
+        } else
+            m_assembler.shll_CLr(dest);
+    }
+    
+    // Take the value from dividend, divide it by divisor, and put the remainder in remainder.
+    // For now, this operation has specific register requirements, and the three register must
+    // be unique.  It is unfortunate to expose this in the MacroAssembler interface, however
+    // given the complexity to fix, the fact that it is not uncommmon  for processors to have
+    // specific register requirements on this operation (e.g. Mips result in 'hi'), or to not
+    // support a hardware divide at all, it may not be 
+    void mod32(RegisterID divisor, RegisterID dividend, RegisterID remainder)
+    {
+#ifdef NDEBUG
+#pragma unused(dividend,remainder)
+#else
+        ASSERT((dividend == X86::eax) && (remainder == X86::edx));
+        ASSERT((dividend != divisor) && (remainder != divisor));
+#endif
+
+        m_assembler.cdq();
+        m_assembler.idivl_r(divisor);
+    }
+
     void mul32(Imm32 imm, RegisterID src, RegisterID dest)
     {
@@ -356 +482 @@
     {
         m_assembler.sarl_i8r(imm.m_value, dest);
+    }
+
+    void rshift32(RegisterID shift_amount, RegisterID dest)
+    {
+        // On x86 we can only shift by ecx; if asked to shift by another register we'll
+        // need rejig the shift amount into ecx first, and restore the registers afterwards.
+        if (shift_amount != X86::ecx) {
+            m_assembler.xchgl_rr(shift_amount, X86::ecx);
+
+            // E.g. transform "shll %eax, %eax" -> "xchgl %eax, %ecx; shll %ecx, %ecx; xchgl %eax, %ecx"
+            if (dest == shift_amount)
+                m_assembler.sarl_CLr(X86::ecx);
+            // E.g. transform "shll %eax, %ecx" -> "xchgl %eax, %ecx; shll %ecx, %eax; xchgl %eax, %ecx"
+            else if (dest == X86::ecx)
+                m_assembler.sarl_CLr(shift_amount);
+            // E.g. transform "shll %eax, %ebx" -> "xchgl %eax, %ecx; shll %ecx, %ebx; xchgl %eax, %ecx"
+            else
+                m_assembler.sarl_CLr(dest);
+        
+            m_assembler.xchgl_rr(shift_amount, X86::ecx);
+        } else
+            m_assembler.sarl_CLr(dest);
     }
 
@@ -478 +626 @@
         store32(src, address);
     }
-#endif
-    
+
+    DataLabelPtr storePtrWithRepatch(Address address)
+    {
+        if (address.offset)
+            m_assembler.movl_i32m(0, address.offset, address.base);
+        else
+            m_assembler.movl_i32m(0, address.base);
+        return DataLabelPtr(this);
+    }
+#endif
+
     void store32(RegisterID src, ImplicitAddress address)
     {
@@ -865 +1022 @@
         return jnz32(reg, mask);
     }
+
+    Jump jnzPtr(Address address, Imm32 mask = Imm32(-1))
+    {
+        return jnz32(address, mask);
+    }
 #endif
 
@@ -883 +1045 @@
     {
         return jz32(reg, mask);
+    }
+
+    Jump jzPtr(Address address, Imm32 mask = Imm32(-1))
+    {
+        return jz32(address, mask);
     }
 
@@ -980 +1147 @@
     {
         m_assembler.link(m_assembler.jmp(), target.m_label);
+    }
+
+    void jump(RegisterID target)
+    {
+        m_assembler.jmp_r(target);
+    }
+
+    // Address is a memory location containing the address to jump to
+    void jump(Address address)
+    {
+        if (address.offset)
+            m_assembler.jmp_m(address.offset, address.base);
+        else
+            m_assembler.jmp_m(address.base);
     }
 
@@ -1057 +1238 @@
     }
 
-    void jump(RegisterID target)
-    {
-        m_assembler.jmp_r(target);
+    Label label()
+    {
+        return Label(this);
     }