LCOV - app.info - js/src/assembler/assembler/MacroAssembler.h

LCOV - code coverage report
| Current view: | directory - js/src/assembler/assembler - MacroAssembler.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 83 | 83 | 100.0 %
| Date: | 2012-04-07 | Functions: | 33 | 33 | 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          768214 : 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            2193 :     void peek(RegisterID dest, int index = 0)
          89                 :     {
          90            2193 :         loadPtr(Address(stackPointerRegister, (index * sizeof(void*))), dest);
          91            2193 :     }
          92                 :
          93            2481 :     void poke(RegisterID src, int index = 0)
          94                 :     {
          95            2481 :         storePtr(src, Address(stackPointerRegister, (index * sizeof(void*))));
          96            2481 :     }
          97                 :
          98             243 :     void poke(TrustedImm32 value, int index = 0)
          99                 :     {
         100             243 :         store32(value, Address(stackPointerRegister, (index * sizeof(void*))));
         101             243 :     }
         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              45 :     void branch32(Condition cond, RegisterID left, Address right, Label target)
         126                 :     {
         127              45 :         branch32(cond, left, right).linkTo(target, this);
         128              45 :     }
         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           29728 :     void jump(Label target)
         141                 :     {
         142           29728 :         jump().linkTo(target, this);
         143           29728 :     }
         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             855 :     void addPtr(RegisterID src, RegisterID dest)
         151                 :     {
         152             855 :         add32(src, dest);
         153             855 :     }
         154                 :
         155                 :     void addPtr(Imm32 imm32, Address address)
         156                 :     {
         157                 :         add32(imm32, address);
         158                 :     }
         159                 :
         160         2811116 :     void addPtr(Imm32 imm, RegisterID srcDest)
         161                 :     {
         162         2811116 :         add32(imm, srcDest);
         163         2811116 :     }
         164                 :
         165              94 :     void addPtr(ImmPtr imm, RegisterID dest)
         166                 :     {
         167              94 :         add32(Imm32(imm), dest);
         168              94 :     }
         169                 :
         170         2753468 :     void addPtr(Imm32 imm, RegisterID src, RegisterID dest)
         171                 :     {
         172         2753468 :         add32(imm, src, dest);
         173         2753468 :     }
         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             750 :     void negPtr(RegisterID srcDest)
         191                 :     {
         192             750 :         neg32(srcDest);
         193             750 :     }
         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                 :     void subPtr(RegisterID src, RegisterID dest)
         216                 :     {
         217                 :         sub32(src, dest);
         218                 :     }
         219                 :
         220           20560 :     void subPtr(Imm32 imm, RegisterID dest)
         221                 :     {
         222           20560 :         sub32(imm, dest);
         223           20560 :     }
         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         4412969 :     void loadPtr(ImplicitAddress address, RegisterID dest)
         247                 :     {
         248         4412969 :         load32(address, dest);
         249         4412969 :     }
         250                 :
         251                 :     void loadPtr(BaseIndex address, RegisterID dest)
         252                 :     {
         253                 :         load32(address, dest);
         254                 :     }
         255                 :
         256          441078 :     void loadPtr(void* address, RegisterID dest)
         257                 :     {
         258          441078 :         load32(address, dest);
         259          441078 :     }
         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         5504933 :     void storePtr(RegisterID src, ImplicitAddress address)
         272                 :     {
         273         5504933 :         store32(src, address);
         274         5504933 :     }
         275                 :
         276           17863 :     void storePtr(RegisterID src, void* address)
         277                 :     {
         278           17863 :         store32(src, address);
         279           17863 :     }
         280                 :
         281         2960582 :     void storePtr(TrustedImmPtr imm, ImplicitAddress address)
         282                 :     {
         283         2960582 :         store32(Imm32(imm), address);
         284         2960582 :     }
         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           14796 :     Jump branchPtr(Condition cond, RegisterID left, RegisterID right)
         303                 :     {
         304           14796 :         return branch32(cond, left, right);
         305                 :     }
         306                 :
         307          285953 :     Jump branchPtr(Condition cond, RegisterID left, ImmPtr right)
         308                 :     {
         309          285953 :         return branch32(cond, left, Imm32(right));
         310                 :     }
         311                 :
         312            2245 :     Jump branchPtr(Condition cond, RegisterID left, Imm32 right)
         313                 :     {
         314            2245 :         return branch32(cond, left, right);
         315                 :     }
         316                 :
         317           48833 :     Jump branchPtr(Condition cond, RegisterID left, Address right)
         318                 :     {
         319           48833 :         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           17863 :     Jump branchPtr(Condition cond, AbsoluteAddress left, RegisterID right)
         328                 :     {
         329           17863 :         return branch32(cond, left, right);
         330                 :     }
         331                 :
         332          216655 :     Jump branchPtr(Condition cond, Address left, ImmPtr right)
         333                 :     {
         334          216655 :         return branch32(cond, left, Imm32(right));
         335                 :     }
         336                 :
         337            1231 :     Jump branchPtr(Condition cond, AbsoluteAddress left, ImmPtr right, RegisterID scratch)
         338                 :     {
         339            1231 :         return branch32(cond, left, Imm32(right));
         340                 :     }
         341                 :
         342          206719 :     Jump branchTestPtr(Condition cond, RegisterID reg, RegisterID mask)
         343                 :     {
         344          206719 :         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            2700 :     Jump branchTest8(Condition cond, ExtendedAddress address, Imm32 mask = Imm32(-1))
         375                 :     {
         376            2700 :         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            1105 :     void lshiftPtr(Imm32 imm, RegisterID dest)
         385                 :     {
         386            1105 :         lshift32(imm, dest);
         387            1105 :     }
         388                 : #endif
         389                 :
         390                 : };
         391                 :
         392                 : } // namespace JSC
         393                 :
         394                 : #endif // ENABLE(ASSEMBLER)
         395                 :
         396                 : #endif // MacroAssembler_h

Generated by: LCOV version 1.7