code.vuplus.com Git - vuplus_webkit/blob - Source/JavaScriptCore/assembler/MacroAssemblerX86.h

   1 /*
   2  * Copyright (C) 2008 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef MacroAssemblerX86_h
  27 #define MacroAssemblerX86_h
  28
  29 #if ENABLE(ASSEMBLER) && CPU(X86)
  30
  31 #include "MacroAssemblerX86Common.h"
  32
  33 namespace JSC {
  34
  35 class MacroAssemblerX86 : public MacroAssemblerX86Common {
  36 public:
  37     MacroAssemblerX86()
  38         : m_isSSE2Present(isSSE2Present())
  39     {
  40     }
  41
  42     static const Scale ScalePtr = TimesFour;
  43
  44     using MacroAssemblerX86Common::add32;
  45     using MacroAssemblerX86Common::and32;
  46     using MacroAssemblerX86Common::branchAdd32;
  47     using MacroAssemblerX86Common::sub32;
  48     using MacroAssemblerX86Common::or32;
  49     using MacroAssemblerX86Common::load32;
  50     using MacroAssemblerX86Common::store32;
  51     using MacroAssemblerX86Common::branch32;
  52     using MacroAssemblerX86Common::call;
  53     using MacroAssemblerX86Common::loadDouble;
  54     using MacroAssemblerX86Common::convertInt32ToDouble;
  55
  56     void add32(TrustedImm32 imm, RegisterID src, RegisterID dest)
  57     {
  58         m_assembler.leal_mr(imm.m_value, src, dest);
  59     }
  60
  61     void add32(TrustedImm32 imm, AbsoluteAddress address)
  62     {
  63         m_assembler.addl_im(imm.m_value, address.m_ptr);
  64     }
  65
  66     void addWithCarry32(TrustedImm32 imm, AbsoluteAddress address)
  67     {
  68         m_assembler.adcl_im(imm.m_value, address.m_ptr);
  69     }
  70
  71     void and32(TrustedImm32 imm, AbsoluteAddress address)
  72     {
  73         m_assembler.andl_im(imm.m_value, address.m_ptr);
  74     }
  75
  76     void or32(TrustedImm32 imm, AbsoluteAddress address)
  77     {
  78         m_assembler.orl_im(imm.m_value, address.m_ptr);
  79     }
  80
  81     void sub32(TrustedImm32 imm, AbsoluteAddress address)
  82     {
  83         m_assembler.subl_im(imm.m_value, address.m_ptr);
  84     }
  85
  86     void load32(void* address, RegisterID dest)
  87     {
  88         m_assembler.movl_mr(address, dest);
  89     }
  90
  91     void loadDouble(const void* address, FPRegisterID dest)
  92     {
  93         ASSERT(isSSE2Present());
  94         m_assembler.movsd_mr(address, dest);
  95     }
  96
  97     void convertInt32ToDouble(AbsoluteAddress src, FPRegisterID dest)
  98     {
  99         m_assembler.cvtsi2sd_mr(src.m_ptr, dest);
 100     }
 101
 102     void store32(TrustedImm32 imm, void* address)
 103     {
 104         m_assembler.movl_i32m(imm.m_value, address);
 105     }
 106
 107     void store32(RegisterID src, void* address)
 108     {
 109         m_assembler.movl_rm(src, address);
 110     }
 111
 112     Jump branchAdd32(ResultCondition cond, TrustedImm32 src, AbsoluteAddress dest)
 113     {
 114         m_assembler.addl_im(src.m_value, dest.m_ptr);
 115         return Jump(m_assembler.jCC(x86Condition(cond)));
 116     }
 117
 118     Jump branch32(RelationalCondition cond, AbsoluteAddress left, RegisterID right)
 119     {
 120         m_assembler.cmpl_rm(right, left.m_ptr);
 121         return Jump(m_assembler.jCC(x86Condition(cond)));
 122     }
 123
 124     Jump branch32(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
 125     {
 126         m_assembler.cmpl_im(right.m_value, left.m_ptr);
 127         return Jump(m_assembler.jCC(x86Condition(cond)));
 128     }
 129
 130     Call call()
 131     {
 132         return Call(m_assembler.call(), Call::Linkable);
 133     }
 134
 135     Call tailRecursiveCall()
 136     {
 137         return Call::fromTailJump(jump());
 138     }
 139
 140     Call makeTailRecursiveCall(Jump oldJump)
 141     {
 142         return Call::fromTailJump(oldJump);
 143     }
 144
 145
 146     DataLabelPtr moveWithPatch(TrustedImmPtr initialValue, RegisterID dest)
 147     {
 148         m_assembler.movl_i32r(initialValue.asIntptr(), dest);
 149         return DataLabelPtr(this);
 150     }
 151
 152     Jump branchPtrWithPatch(RelationalCondition cond, RegisterID left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
 153     {
 154         m_assembler.cmpl_ir_force32(initialRightValue.asIntptr(), left);
 155         dataLabel = DataLabelPtr(this);
 156         return Jump(m_assembler.jCC(x86Condition(cond)));
 157     }
 158
 159     Jump branchPtrWithPatch(RelationalCondition cond, Address left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
 160     {
 161         m_assembler.cmpl_im_force32(initialRightValue.asIntptr(), left.offset, left.base);
 162         dataLabel = DataLabelPtr(this);
 163         return Jump(m_assembler.jCC(x86Condition(cond)));
 164     }
 165
 166     DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, ImplicitAddress address)
 167     {
 168         m_assembler.movl_i32m(initialValue.asIntptr(), address.offset, address.base);
 169         return DataLabelPtr(this);
 170     }
 171
 172     bool supportsFloatingPoint() const { return m_isSSE2Present; }
 173     // See comment on MacroAssemblerARMv7::supportsFloatingPointTruncate()
 174     bool supportsFloatingPointTruncate() const { return m_isSSE2Present; }
 175     bool supportsFloatingPointSqrt() const { return m_isSSE2Present; }
 176     bool supportsDoubleBitops() const { return m_isSSE2Present; }
 177
 178 private:
 179     const bool m_isSSE2Present;
 180
 181     friend class LinkBuffer;
 182     friend class RepatchBuffer;
 183
 184     static void linkCall(void* code, Call call, FunctionPtr function)
 185     {
 186         X86Assembler::linkCall(code, call.m_label, function.value());
 187     }
 188
 189     static void repatchCall(CodeLocationCall call, CodeLocationLabel destination)
 190     {
 191         X86Assembler::relinkCall(call.dataLocation(), destination.executableAddress());
 192     }
 193
 194     static void repatchCall(CodeLocationCall call, FunctionPtr destination)
 195     {
 196         X86Assembler::relinkCall(call.dataLocation(), destination.executableAddress());
 197     }
 198 };
 199
 200 } // namespace JSC
 201
 202 #endif // ENABLE(ASSEMBLER)
 203
 204 #endif // MacroAssemblerX86_h