LCOV - code coverage report
Current view: directory - js/src/assembler/assembler - MacroAssembler.h (source / functions) Found Hit Coverage
Test: app.info Lines: 86 86 100.0 %
Date: 2012-06-02 Functions: 34 34 100.0 %

       1                 : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
       2                 :  * vim: set ts=8 sw=4 et tw=79:
       3                 :  *
       4                 :  * ***** BEGIN LICENSE BLOCK *****
       5                 :  * Copyright (C) 2008 Apple Inc. All rights reserved.
       6                 :  *
       7                 :  * Redistribution and use in source and binary forms, with or without
       8                 :  * modification, are permitted provided that the following conditions
       9                 :  * are met:
      10                 :  * 1. Redistributions of source code must retain the above copyright
      11                 :  *    notice, this list of conditions and the following disclaimer.
      12                 :  * 2. Redistributions in binary form must reproduce the above copyright
      13                 :  *    notice, this list of conditions and the following disclaimer in the
      14                 :  *    documentation and/or other materials provided with the distribution.
      15                 :  *
      16                 :  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
      17                 :  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      18                 :  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
      19                 :  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
      20                 :  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
      21                 :  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
      22                 :  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
      23                 :  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
      24                 :  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      25                 :  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
      26                 :  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
      27                 :  * 
      28                 :  * ***** END LICENSE BLOCK ***** */
      29                 : 
      30                 : #ifndef MacroAssembler_h
      31                 : #define MacroAssembler_h
      32                 : 
      33                 : #include "assembler/wtf/Platform.h"
      34                 : 
      35                 : #if ENABLE_ASSEMBLER
      36                 : 
      37                 : #if WTF_CPU_ARM_THUMB2
      38                 : #include "MacroAssemblerARMv7.h"
      39                 : namespace JSC { typedef MacroAssemblerARMv7 MacroAssemblerBase; }
      40                 : 
      41                 : #elif WTF_CPU_ARM_TRADITIONAL
      42                 : #include "MacroAssemblerARM.h"
      43                 : namespace JSC { typedef MacroAssemblerARM MacroAssemblerBase; }
      44                 : 
      45                 : #elif WTF_CPU_MIPS
      46                 : #include "MacroAssemblerMIPS.h"
      47                 : namespace JSC { typedef MacroAssemblerMIPS MacroAssemblerBase; }
      48                 : 
      49                 : #elif WTF_CPU_X86
      50                 : #include "MacroAssemblerX86.h"
      51                 : namespace JSC { typedef MacroAssemblerX86 MacroAssemblerBase; }
      52                 : 
      53                 : #elif WTF_CPU_X86_64
      54                 : #include "MacroAssemblerX86_64.h"
      55                 : namespace JSC { typedef MacroAssemblerX86_64 MacroAssemblerBase; }
      56                 : 
      57                 : #elif WTF_CPU_SPARC
      58                 : #include "MacroAssemblerSparc.h"
      59                 : namespace JSC { typedef MacroAssemblerSparc MacroAssemblerBase; }
      60                 : 
      61                 : #else
      62                 : #error "The MacroAssembler is not supported on this platform."
      63                 : #endif
      64                 : 
      65                 : 
      66                 : namespace JSC {
      67                 : 
      68         1526632 : class MacroAssembler : public MacroAssemblerBase {
      69                 : public:
      70                 : 
      71                 :     using MacroAssemblerBase::pop;
      72                 :     using MacroAssemblerBase::jump;
      73                 :     using MacroAssemblerBase::branch32;
      74                 :     using MacroAssemblerBase::branch16;
      75                 : #if WTF_CPU_X86_64
      76                 :     using MacroAssemblerBase::branchPtr;
      77                 :     using MacroAssemblerBase::branchTestPtr;
      78                 : #endif
      79                 : 
      80                 : 
      81                 :     // Platform agnostic onvenience functions,
      82                 :     // described in terms of other macro assembly methods.
      83                 :     void pop()
      84                 :     {
      85                 :         addPtr(Imm32(sizeof(void*)), stackPointerRegister);
      86                 :     }
      87                 :     
      88           35313 :     void peek(RegisterID dest, int index = 0)
      89                 :     {
      90           35313 :         loadPtr(Address(stackPointerRegister, (index * sizeof(void*))), dest);
      91           35313 :     }
      92                 : 
      93           44954 :     void poke(RegisterID src, int index = 0)
      94                 :     {
      95           44954 :         storePtr(src, Address(stackPointerRegister, (index * sizeof(void*))));
      96           44954 :     }
      97                 : 
      98            6924 :     void poke(TrustedImm32 value, int index = 0)
      99                 :     {
     100            6924 :         store32(value, Address(stackPointerRegister, (index * sizeof(void*))));
     101            6924 :     }
     102                 : 
     103                 :     void poke(TrustedImmPtr imm, int index = 0)
     104                 :     {
     105                 :         storePtr(imm, Address(stackPointerRegister, (index * sizeof(void*))));
     106                 :     }
     107                 : 
     108                 : 
     109                 :     // Backwards banches, these are currently all implemented using existing forwards branch mechanisms.
     110                 :     void branchPtr(Condition cond, RegisterID op1, ImmPtr imm, Label target)
     111                 :     {
     112                 :         branchPtr(cond, op1, imm).linkTo(target, this);
     113                 :     }
     114                 : 
     115                 :     void branch32(Condition cond, RegisterID op1, RegisterID op2, Label target)
     116                 :     {
     117                 :         branch32(cond, op1, op2).linkTo(target, this);
     118                 :     }
     119                 : 
     120                 :     void branch32(Condition cond, RegisterID op1, TrustedImm32 imm, Label target)
     121                 :     {
     122                 :         branch32(cond, op1, imm).linkTo(target, this);
     123                 :     }
     124                 : 
     125            2717 :     void branch32(Condition cond, RegisterID left, Address right, Label target)
     126                 :     {
     127            2717 :         branch32(cond, left, right).linkTo(target, this);
     128            2717 :     }
     129                 : 
     130                 :     void branch16(Condition cond, BaseIndex left, RegisterID right, Label target)
     131                 :     {
     132                 :         branch16(cond, left, right).linkTo(target, this);
     133                 :     }
     134                 :     
     135                 :     void branchTestPtr(Condition cond, RegisterID reg, Label target)
     136                 :     {
     137                 :         branchTestPtr(cond, reg).linkTo(target, this);
     138                 :     }
     139                 : 
     140          144521 :     void jump(Label target)
     141                 :     {
     142          144521 :         jump().linkTo(target, this);
     143          144521 :     }
     144                 : 
     145                 : 
     146                 :     // Ptr methods
     147                 :     // On 32-bit platforms (i.e. x86), these methods directly map onto their 32-bit equivalents.
     148                 :     // FIXME: should this use a test for 32-bitness instead of this specific exception?
     149                 : #if !WTF_CPU_X86_64
     150            1073 :     void addPtr(RegisterID src, RegisterID dest)
     151                 :     {
     152            1073 :         add32(src, dest);
     153            1073 :     }
     154                 : 
     155                 :     void addPtr(Imm32 imm32, Address address)
     156                 :     {
     157                 :         add32(imm32, address);
     158                 :     }
     159                 : 
     160         5108276 :     void addPtr(Imm32 imm, RegisterID srcDest)
     161                 :     {
     162         5108276 :         add32(imm, srcDest);
     163         5108276 :     }
     164                 : 
     165              94 :     void addPtr(ImmPtr imm, RegisterID dest)
     166                 :     {
     167              94 :         add32(Imm32(imm), dest);
     168              94 :     }
     169                 : 
     170         5028715 :     void addPtr(Imm32 imm, RegisterID src, RegisterID dest)
     171                 :     {
     172         5028715 :         add32(imm, src, dest);
     173         5028715 :     }
     174                 : 
     175                 :     void andPtr(RegisterID src, RegisterID dest)
     176                 :     {
     177                 :         and32(src, dest);
     178                 :     }
     179                 : 
     180                 :     void andPtr(Imm32 imm, RegisterID srcDest)
     181                 :     {
     182                 :         and32(imm, srcDest);
     183                 :     }
     184                 : 
     185             105 :     void andPtr(ImmPtr ptr, RegisterID srcDest)
     186                 :     {
     187             105 :         and32(Imm32(ptr), srcDest);
     188             105 :     }
     189                 : 
     190             536 :     void negPtr(RegisterID srcDest)
     191                 :     {
     192             536 :         neg32(srcDest);
     193             536 :     }
     194                 : 
     195                 :     void notPtr(RegisterID srcDest)
     196                 :     {
     197                 :         not32(srcDest);
     198                 :     }
     199                 : 
     200                 :     void orPtr(RegisterID src, RegisterID dest)
     201                 :     {
     202                 :         or32(src, dest);
     203                 :     }
     204                 : 
     205                 :     void orPtr(ImmPtr imm, RegisterID dest)
     206                 :     {
     207                 :         or32(Imm32(imm), dest);
     208                 :     }
     209                 : 
     210                 :     void orPtr(Imm32 imm, RegisterID dest)
     211                 :     {
     212                 :         or32(imm, dest);
     213                 :     }
     214                 : 
     215             864 :     void subPtr(RegisterID src, RegisterID dest)
     216                 :     {
     217             864 :         sub32(src, dest);
     218             864 :     }
     219                 :     
     220           62997 :     void subPtr(Imm32 imm, RegisterID dest)
     221                 :     {
     222           62997 :         sub32(imm, dest);
     223           62997 :     }
     224                 :     
     225                 :     void subPtr(ImmPtr imm, RegisterID dest)
     226                 :     {
     227                 :         sub32(Imm32(imm), dest);
     228                 :     }
     229                 : 
     230                 :     void subPtr(ImmPtr imm, Address address)
     231                 :     {
     232                 :         sub32(Imm32(imm), address);
     233                 :     }
     234                 : 
     235                 :     void xorPtr(RegisterID src, RegisterID dest)
     236                 :     {
     237                 :         xor32(src, dest);
     238                 :     }
     239                 : 
     240                 :     void xorPtr(Imm32 imm, RegisterID srcDest)
     241                 :     {
     242                 :         xor32(imm, srcDest);
     243                 :     }
     244                 : 
     245                 : 
     246         8108903 :     void loadPtr(ImplicitAddress address, RegisterID dest)
     247                 :     {
     248         8108903 :         load32(address, dest);
     249         8108903 :     }
     250                 : 
     251                 :     void loadPtr(BaseIndex address, RegisterID dest)
     252                 :     {
     253                 :         load32(address, dest);
     254                 :     }
     255                 : 
     256          431088 :     void loadPtr(void* address, RegisterID dest)
     257                 :     {
     258          431088 :         load32(address, dest);
     259          431088 :     }
     260                 : 
     261                 :     DataLabel32 loadPtrWithAddressOffsetPatch(Address address, RegisterID dest)
     262                 :     {
     263                 :         return load32WithAddressOffsetPatch(address, dest);
     264                 :     }
     265                 : 
     266             156 :     void setPtr(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
     267                 :     {
     268             156 :         set32(cond, left, right, dest);
     269             156 :     }
     270                 : 
     271        10075537 :     void storePtr(RegisterID src, ImplicitAddress address)
     272                 :     {
     273        10075537 :         store32(src, address);
     274        10075537 :     }
     275                 : 
     276           19127 :     void storePtr(RegisterID src, void* address)
     277                 :     {
     278           19127 :         store32(src, address);
     279           19127 :     }
     280                 : 
     281         5289399 :     void storePtr(TrustedImmPtr imm, ImplicitAddress address)
     282                 :     {
     283         5289399 :         store32(Imm32(imm), address);
     284         5289399 :     }
     285                 : 
     286                 :     void storePtr(TrustedImmPtr imm, BaseIndex address)
     287                 :     {
     288                 :         store32(Imm32(imm), address);
     289                 :     }
     290                 : 
     291                 :     void storePtr(TrustedImmPtr imm, void* address)
     292                 :     {
     293                 :         store32(Imm32(imm), address);
     294                 :     }
     295                 : 
     296                 :     DataLabel32 storePtrWithAddressOffsetPatch(RegisterID src, Address address)
     297                 :     {
     298                 :         return store32WithAddressOffsetPatch(src, address);
     299                 :     }
     300                 : 
     301                 : 
     302           16916 :     Jump branchPtr(Condition cond, RegisterID left, RegisterID right)
     303                 :     {
     304           16916 :         return branch32(cond, left, right);
     305                 :     }
     306                 : 
     307          515276 :     Jump branchPtr(Condition cond, RegisterID left, ImmPtr right)
     308                 :     {
     309          515276 :         return branch32(cond, left, Imm32(right));
     310                 :     }
     311                 : 
     312           10714 :     Jump branchPtr(Condition cond, RegisterID left, Imm32 right)
     313                 :     {
     314           10714 :         return branch32(cond, left, right);
     315                 :     }
     316                 : 
     317           84053 :     Jump branchPtr(Condition cond, RegisterID left, Address right)
     318                 :     {
     319           84053 :         return branch32(cond, left, right);
     320                 :     }
     321                 : 
     322              10 :     Jump branchPtr(Condition cond, Address left, RegisterID right)
     323                 :     {
     324              10 :         return branch32(cond, left, right);
     325                 :     }
     326                 : 
     327           19127 :     Jump branchPtr(Condition cond, AbsoluteAddress left, RegisterID right)
     328                 :     {
     329           19127 :         return branch32(cond, left, right);
     330                 :     }
     331                 : 
     332          318864 :     Jump branchPtr(Condition cond, Address left, ImmPtr right)
     333                 :     {
     334          318864 :         return branch32(cond, left, Imm32(right));
     335                 :     }
     336                 : 
     337            6271 :     Jump branchPtr(Condition cond, AbsoluteAddress left, ImmPtr right, RegisterID scratch)
     338                 :     {
     339            6271 :         return branch32(cond, left, Imm32(right));
     340                 :     }
     341                 : 
     342          486838 :     Jump branchTestPtr(Condition cond, RegisterID reg, RegisterID mask)
     343                 :     {
     344          486838 :         return branchTest32(cond, reg, mask);
     345                 :     }
     346                 : 
     347             105 :     Jump branchTestPtr(Condition cond, RegisterID reg, Imm32 mask = Imm32(-1))
     348                 :     {
     349             105 :         return branchTest32(cond, reg, mask);
     350                 :     }
     351                 : 
     352                 :     Jump branchTestPtr(Condition cond, Address address, Imm32 mask = Imm32(-1))
     353                 :     {
     354                 :         return branchTest32(cond, address, mask);
     355                 :     }
     356                 : 
     357                 :     Jump branchTestPtr(Condition cond, BaseIndex address, Imm32 mask = Imm32(-1))
     358                 :     {
     359                 :         return branchTest32(cond, address, mask);
     360                 :     }
     361                 : 
     362                 : 
     363                 :     Jump branchAddPtr(Condition cond, RegisterID src, RegisterID dest)
     364                 :     {
     365                 :         return branchAdd32(cond, src, dest);
     366                 :     }
     367                 : 
     368                 :     Jump branchSubPtr(Condition cond, Imm32 imm, RegisterID dest)
     369                 :     {
     370                 :         return branchSub32(cond, imm, dest);
     371                 :     }
     372                 :         
     373                 :     using MacroAssemblerBase::branchTest8;
     374            3435 :     Jump branchTest8(Condition cond, ExtendedAddress address, Imm32 mask = Imm32(-1))
     375                 :     {
     376            3435 :         return MacroAssemblerBase::branchTest8(cond, Address(address.base, address.offset), mask);
     377                 :     }
     378                 : 
     379             105 :     void rshiftPtr(Imm32 imm, RegisterID dest)
     380                 :     {
     381             105 :         rshift32(imm, dest);
     382             105 :     }
     383                 : 
     384            1323 :     void lshiftPtr(Imm32 imm, RegisterID dest)
     385                 :     {
     386            1323 :         lshift32(imm, dest);
     387            1323 :     }
     388                 : #endif
     389                 : 
     390                 : };
     391                 : 
     392                 : } // namespace JSC
     393                 : 
     394                 : #endif // ENABLE(ASSEMBLER)
     395                 : 
     396                 : #endif // MacroAssembler_h

Generated by: LCOV version 1.7