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::sub32;

    47     using MacroAssemblerX86Common::or32;

    48     using MacroAssemblerX86Common::load32;

    49     using MacroAssemblerX86Common::store32;

    50     using MacroAssemblerX86Common::branch32;

    51     using MacroAssemblerX86Common::call;

    52     using MacroAssemblerX86Common::loadDouble;

    53     using MacroAssemblerX86Common::convertInt32ToDouble;

    54 

    55     void add32(Imm32 imm, RegisterID src, RegisterID dest)

    56     {

    57         m_assembler.leal_mr(imm.m_value, src, dest);

    58     }

    59 

    60     void add32(Imm32 imm, AbsoluteAddress address)

    61     {

    62         m_assembler.addl_im(imm.m_value, address.m_ptr);

    63     }

    64     

    65     void addWithCarry32(Imm32 imm, AbsoluteAddress address)

    66     {

    67         m_assembler.adcl_im(imm.m_value, address.m_ptr);

    68     }

    69     

    70     void and32(Imm32 imm, AbsoluteAddress address)

    71     {

    72         m_assembler.andl_im(imm.m_value, address.m_ptr);

    73     }

    74     

    75     void or32(Imm32 imm, AbsoluteAddress address)

    76     {

    77         m_assembler.orl_im(imm.m_value, address.m_ptr);

    78     }

    79 

    80     void sub32(Imm32 imm, AbsoluteAddress address)

    81     {

    82         m_assembler.subl_im(imm.m_value, address.m_ptr);

    83     }

    84 

    85     void load32(void* address, RegisterID dest)

    86     {

    87         m_assembler.movl_mr(address, dest);

    88     }

    89 

    90     void loadDouble(const void* address, FPRegisterID dest)

    91     {

    92         ASSERT(isSSE2Present());

    93         m_assembler.movsd_mr(address, dest);

    94     }

    95 

    96     void convertInt32ToDouble(AbsoluteAddress src, FPRegisterID dest)

    97     {

    98         m_assembler.cvtsi2sd_mr(src.m_ptr, dest);

    99     }

   100 

   101     void store32(Imm32 imm, void* address)

   102     {

   103         m_assembler.movl_i32m(imm.m_value, address);

   104     }

   105 

   106     void store32(RegisterID src, void* address)

   107     {

   108         m_assembler.movl_rm(src, address);

   109     }

   110 

   111     Jump branch32(Condition cond, AbsoluteAddress left, RegisterID right)

   112     {

   113         m_assembler.cmpl_rm(right, left.m_ptr);

   114         return Jump(m_assembler.jCC(x86Condition(cond)));

   115     }

   116 

   117     Jump branch32(Condition cond, AbsoluteAddress left, Imm32 right)

   118     {

   119         m_assembler.cmpl_im(right.m_value, left.m_ptr);

   120         return Jump(m_assembler.jCC(x86Condition(cond)));

   121     }

   122 

   123     Call call()

   124     {

   125         return Call(m_assembler.call(), Call::Linkable);

   126     }

   127 

   128     Call tailRecursiveCall()

   129     {

   130         return Call::fromTailJump(jump());

   131     }

   132 

   133     Call makeTailRecursiveCall(Jump oldJump)

   134     {

   135         return Call::fromTailJump(oldJump);

   136     }

   137 

   138 

   139     DataLabelPtr moveWithPatch(ImmPtr initialValue, RegisterID dest)

   140     {

   141         m_assembler.movl_i32r(initialValue.asIntptr(), dest);

   142         return DataLabelPtr(this);

   143     }

   144 

   145     Jump branchPtrWithPatch(Condition cond, RegisterID left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))

   146     {

   147         m_assembler.cmpl_ir_force32(initialRightValue.asIntptr(), left);

   148         dataLabel = DataLabelPtr(this);

   149         return Jump(m_assembler.jCC(x86Condition(cond)));

   150     }

   151 

   152     Jump branchPtrWithPatch(Condition cond, Address left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))

   153     {

   154         m_assembler.cmpl_im_force32(initialRightValue.asIntptr(), left.offset, left.base);

   155         dataLabel = DataLabelPtr(this);

   156         return Jump(m_assembler.jCC(x86Condition(cond)));

   157     }

   158 

   159     DataLabelPtr storePtrWithPatch(ImmPtr initialValue, ImplicitAddress address)

   160     {

   161         m_assembler.movl_i32m(initialValue.asIntptr(), address.offset, address.base);

   162         return DataLabelPtr(this);

   163     }

   164 

   165     Label loadPtrWithPatchToLEA(Address address, RegisterID dest)

   166     {

   167         Label label(this);

   168         load32(address, dest);

   169         return label;

   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 

   177 private:

   178     const bool m_isSSE2Present;

   179 

   180     friend class LinkBuffer;

   181     friend class RepatchBuffer;

   182 

   183     static void linkCall(void* code, Call call, FunctionPtr function)

   184     {

   185         X86Assembler::linkCall(code, call.m_jmp, function.value());

   186     }

   187 

   188     static void repatchCall(CodeLocationCall call, CodeLocationLabel destination)

   189     {

   190         X86Assembler::relinkCall(call.dataLocation(), destination.executableAddress());

   191     }

   192 

   193     static void repatchCall(CodeLocationCall call, FunctionPtr destination)

   194     {

   195         X86Assembler::relinkCall(call.dataLocation(), destination.executableAddress());

   196     }

   197 };

   198 

   199 } // namespace JSC

   200 

   201 #endif // ENABLE(ASSEMBLER)

   202 

   203 #endif // MacroAssemblerX86_h