Ignore:
Timestamp:
Feb 3, 2009, 6:02:32 PM (16 years ago)
Author:
[email protected]
Message:

2009-02-03 Gavin Barraclough <​[email protected]>

Reviewed by Geoff Garen.

​https://bugs.webkit.org/show_bug.cgi?id=23715

Simplify MacroAssembler interface, by combining comparison methods.
Seprate operations are combined as follows:

jz32/jnz32/jzPtr/jnzPtr -> branchTest32/branchTestPtr,
j*(Add|Mul|Sub)32/j*(Add|Mul|Sub)Ptr -> branch(Add|Mul|Sub)32/branch(Add|Mul|Sub)Ptr
j*32/j*Ptr (all other two op combparisons) -> branch32/brnachPtr
set*32 -> set32

Also, represent the Scale of BaseIndex addresses as a plain enum (0,1,2,3),
instead of as multiplicands (1,2,4,8).

This patch singificantly reduces replication of code, and increases functionality supported
by the MacroAssembler. No performance impact.

  • assembler/MacroAssembler.h: (JSC::MacroAssembler::): (JSC::MacroAssembler::branchPtr): (JSC::MacroAssembler::branchPtrWithPatch): (JSC::MacroAssembler::branch32): (JSC::MacroAssembler::branch16): (JSC::MacroAssembler::branchTestPtr): (JSC::MacroAssembler::branchTest32): (JSC::MacroAssembler::branchAddPtr): (JSC::MacroAssembler::branchAdd32): (JSC::MacroAssembler::branchMul32): (JSC::MacroAssembler::branchSubPtr): (JSC::MacroAssembler::branchSub32): (JSC::MacroAssembler::set32): (JSC::MacroAssembler::setTest32):
  • assembler/X86Assembler.h: (JSC::X86Assembler::): (JSC::X86Assembler::jccRel32): (JSC::X86Assembler::setccOpcode): (JSC::X86Assembler::cmpq_mr): (JSC::X86Assembler::setcc_r): (JSC::X86Assembler::sete_r): (JSC::X86Assembler::setne_r): (JSC::X86Assembler::jne): (JSC::X86Assembler::je): (JSC::X86Assembler::jl): (JSC::X86Assembler::jb): (JSC::X86Assembler::jle): (JSC::X86Assembler::jbe): (JSC::X86Assembler::jge): (JSC::X86Assembler::jg): (JSC::X86Assembler::ja): (JSC::X86Assembler::jae): (JSC::X86Assembler::jo): (JSC::X86Assembler::jp): (JSC::X86Assembler::js): (JSC::X86Assembler::jcc): (JSC::X86Assembler::X86InstructionFormatter::putModRmSib):
  • jit/JIT.cpp: (JSC::JIT::compileOpStrictEq): (JSC::JIT::emitSlowScriptCheck): (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompileSlowCases): (JSC::JIT::privateCompile): (JSC::JIT::privateCompileCTIMachineTrampolines):
  • jit/JITArithmetic.cpp: (JSC::JIT::compileFastArith_op_lshift): (JSC::JIT::compileFastArith_op_mod): (JSC::JIT::compileFastArith_op_post_inc): (JSC::JIT::compileFastArith_op_post_dec): (JSC::JIT::compileFastArith_op_pre_inc): (JSC::JIT::compileFastArith_op_pre_dec): (JSC::JIT::compileBinaryArithOp): (JSC::JIT::compileFastArith_op_add): (JSC::JIT::compileFastArith_op_mul):
  • jit/JITCall.cpp: (JSC::JIT::compileOpCall): (JSC::JIT::compileOpCallSlowCase):
  • jit/JITInlineMethods.h: (JSC::JIT::checkStructure): (JSC::JIT::emitJumpIfJSCell): (JSC::JIT::emitJumpIfNotJSCell): (JSC::JIT::emitJumpIfImmediateNumber): (JSC::JIT::emitJumpIfNotImmediateNumber): (JSC::JIT::emitJumpIfImmediateInteger): (JSC::JIT::emitJumpIfNotImmediateInteger): (JSC::JIT::emitFastArithDeTagImmediateJumpIfZero):
  • jit/JITPropertyAccess.cpp: (JSC::JIT::compileGetByIdHotPath): (JSC::JIT::compilePutByIdHotPath): (JSC::JIT::privateCompilePutByIdTransition): (JSC::JIT::privateCompilePatchGetArrayLength): (JSC::JIT::privateCompileGetByIdProto): (JSC::JIT::privateCompileGetByIdProtoList): (JSC::JIT::privateCompileGetByIdChainList): (JSC::JIT::privateCompileGetByIdChain):
  • runtime/RegExp.cpp: (JSC::RegExp::match):
  • wrec/WRECGenerator.cpp: (JSC::WREC::Generator::generateEnter): (JSC::WREC::Generator::generateIncrementIndex): (JSC::WREC::Generator::generateLoadCharacter): (JSC::WREC::Generator::generateJumpIfNotEndOfInput): (JSC::WREC::Generator::generateBackreferenceQuantifier): (JSC::WREC::Generator::generateNonGreedyQuantifier): (JSC::WREC::Generator::generateGreedyQuantifier): (JSC::WREC::Generator::generatePatternCharacterPair): (JSC::WREC::Generator::generatePatternCharacter): (JSC::WREC::Generator::generateCharacterClassInvertedRange): (JSC::WREC::Generator::generateCharacterClassInverted): (JSC::WREC::Generator::generateAssertionBOL): (JSC::WREC::Generator::generateAssertionEOL): (JSC::WREC::Generator::generateAssertionWordBoundary): (JSC::WREC::Generator::generateBackreference):
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/assembler/MacroAssembler.h

    r40004 r40562  
    4848    // Note: do not rely on values in this enum, these will change (to 0..3).
    4949    enum Scale {
    50         TimesOne = 1,
    51         TimesTwo = 2,
    52         TimesFour = 4,
    53         TimesEight = 8,
     50        TimesOne,
     51        TimesTwo,
     52        TimesFour,
     53        TimesEight,
    5454#if PLATFORM(X86)
    5555        ScalePtr = TimesFour
    … …  
    5959#endif
    6060    };
     61
     62    typedef X86Assembler::Condition Condition;
     63    static const Condition Equal = X86Assembler::ConditionE;
     64    static const Condition NotEqual = X86Assembler::ConditionNE;
     65    static const Condition Above = X86Assembler::ConditionA;
     66    static const Condition AboveOrEqual = X86Assembler::ConditionAE;
     67    static const Condition Below = X86Assembler::ConditionB;
     68    static const Condition BelowOrEqual = X86Assembler::ConditionBE;
     69    static const Condition GreaterThan = X86Assembler::ConditionG;
     70    static const Condition GreaterThanOrEqual = X86Assembler::ConditionGE;
     71    static const Condition LessThan = X86Assembler::ConditionL;
     72    static const Condition LessThanOrEqual = X86Assembler::ConditionLE;
     73    static const Condition Overflow = X86Assembler::ConditionO;
     74    static const Condition Zero = X86Assembler::ConditionE;
     75    static const Condition NonZero = X86Assembler::ConditionNE;
    6176
    6277    MacroAssembler()
    … …  
    10931108    // an optional second operand of a mask under which to perform the test.
    10941109
    1095 private:
    1096     void compareImm32ForBranch(RegisterID left, int32_t right)
    1097     {
    1098         m_assembler.cmpl_ir(right, left);
    1099     }
    1100 
    1101     void compareImm32ForBranchEquality(RegisterID reg, int32_t imm)
    1102     {
    1103         if (!imm)
    1104             m_assembler.testl_rr(reg, reg);
     1110public:
     1111    Jump branchPtr(Condition cond, RegisterID left, RegisterID right)
     1112    {
     1113#if PLATFORM(X86_64)
     1114        m_assembler.cmpq_rr(right, left);
     1115        return Jump(m_assembler.jCC(cond));
     1116#else
     1117        return branch32(cond, left, right);
     1118#endif
     1119    }
     1120
     1121    Jump branchPtr(Condition cond, RegisterID left, ImmPtr right)
     1122    {
     1123#if PLATFORM(X86_64)
     1124        intptr_t imm = right.asIntptr();
     1125        if (CAN_SIGN_EXTEND_32_64(imm)) {
     1126            if (!imm)
     1127                m_assembler.testq_rr(left, left);
     1128            else
     1129                m_assembler.cmpq_ir(imm, left);
     1130            return Jump(m_assembler.jCC(cond));
     1131        } else {
     1132            move(right, scratchRegister);
     1133            return branchPtr(cond, left, scratchRegister);
     1134        }
     1135#else
     1136        return branch32(cond, left, Imm32(right));
     1137#endif
     1138    }
     1139
     1140    Jump branchPtr(Condition cond, RegisterID left, Address right)
     1141    {
     1142#if PLATFORM(X86_64)
     1143        m_assembler.cmpq_mr(right.offset, right.base, left);
     1144        return Jump(m_assembler.jCC(cond));
     1145#else
     1146        return branch32(cond, left, right);
     1147#endif
     1148    }
     1149
     1150    Jump branchPtr(Condition cond, AbsoluteAddress left, RegisterID right)
     1151    {
     1152#if PLATFORM(X86_64)
     1153        move(ImmPtr(left.m_ptr), scratchRegister);
     1154        return branchPtr(cond, Address(scratchRegister), right);
     1155#else
     1156        m_assembler.cmpl_rm(right, left.m_ptr);
     1157        return Jump(m_assembler.jCC(cond));
     1158#endif
     1159    }
     1160
     1161    Jump branchPtr(Condition cond, Address left, RegisterID right)
     1162    {
     1163#if PLATFORM(X86_64)
     1164        m_assembler.cmpq_rm(right, left.offset, left.base);
     1165        return Jump(m_assembler.jCC(cond));
     1166#else
     1167        return branch32(cond, left, right);
     1168#endif
     1169    }
     1170
     1171    Jump branchPtr(Condition cond, Address left, ImmPtr right)
     1172    {
     1173#if PLATFORM(X86_64)
     1174        move(right, scratchRegister);
     1175        return branchPtr(cond, left, scratchRegister);
     1176#else
     1177        return branch32(cond, left, Imm32(right));
     1178#endif
     1179    }
     1180
     1181#if !PLATFORM(X86_64)
     1182    Jump branchPtr(Condition cond, AbsoluteAddress left, ImmPtr right)
     1183    {
     1184        m_assembler.cmpl_im(right.asIntptr(), left.m_ptr);
     1185        return Jump(m_assembler.jCC(cond));
     1186    }
     1187#endif
     1188
     1189    Jump branchPtrWithPatch(Condition cond, RegisterID left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))
     1190    {
     1191#if PLATFORM(X86_64)
     1192        m_assembler.movq_i64r(initialRightValue.asIntptr(), scratchRegister);
     1193        dataLabel = DataLabelPtr(this);
     1194        return branchPtr(cond, left, scratchRegister);
     1195#else
     1196        m_assembler.cmpl_ir_force32(initialRightValue.asIntptr(), left);
     1197        dataLabel = DataLabelPtr(this);
     1198        return Jump(m_assembler.jCC(cond));
     1199#endif
     1200    }
     1201
     1202    Jump branchPtrWithPatch(Condition cond, Address left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))
     1203    {
     1204#if PLATFORM(X86_64)
     1205        m_assembler.movq_i64r(initialRightValue.asIntptr(), scratchRegister);
     1206        dataLabel = DataLabelPtr(this);
     1207        return branchPtr(cond, left, scratchRegister);
     1208#else
     1209        m_assembler.cmpl_im_force32(initialRightValue.asIntptr(), left.offset, left.base);
     1210        dataLabel = DataLabelPtr(this);
     1211        return Jump(m_assembler.jCC(cond));
     1212#endif
     1213    }
     1214
     1215    Jump branch32(Condition cond, RegisterID left, RegisterID right)
     1216    {
     1217        m_assembler.cmpl_rr(right, left);
     1218        return Jump(m_assembler.jCC(cond));
     1219    }
     1220
     1221    Jump branch32(Condition cond, RegisterID left, Imm32 right)
     1222    {
     1223        if (((cond == Equal) || (cond == NotEqual)) && !right.m_value)
     1224            m_assembler.testl_rr(left, left);
    11051225        else
    1106             m_assembler.cmpl_ir(imm, reg);
    1107     }
    1108 
    1109     void compareImm32ForBranchEquality(Address address, int32_t imm)
    1110     {
    1111         m_assembler.cmpl_im(imm, address.offset, address.base);
    1112     }
    1113 
    1114     void testImm32(RegisterID reg, Imm32 mask)
    1115     {
     1226            m_assembler.cmpl_ir(right.m_value, left);
     1227        return Jump(m_assembler.jCC(cond));
     1228    }
     1229   
     1230    Jump branch32(Condition cond, RegisterID left, Address right)
     1231    {
     1232        m_assembler.cmpl_mr(right.offset, right.base, left);
     1233        return Jump(m_assembler.jCC(cond));
     1234    }
     1235   
     1236    Jump branch32(Condition cond, Address left, RegisterID right)
     1237    {
     1238        m_assembler.cmpl_rm(right, left.offset, left.base);
     1239        return Jump(m_assembler.jCC(cond));
     1240    }
     1241   
     1242    Jump branch32(Condition cond, Address left, Imm32 right)
     1243    {
     1244        m_assembler.cmpl_im(right.m_value, left.offset, left.base);
     1245        return Jump(m_assembler.jCC(cond));
     1246    }
     1247
     1248    Jump branch16(Condition cond, BaseIndex left, RegisterID right)
     1249    {
     1250        m_assembler.cmpw_rm(right, left.offset, left.base, left.index, left.scale);
     1251        return Jump(m_assembler.jCC(cond));
     1252    }
     1253
     1254    Jump branchTestPtr(Condition cond, RegisterID reg, RegisterID mask)
     1255    {
     1256#if PLATFORM(X86_64)
     1257        m_assembler.testq_rr(reg, mask);
     1258        return Jump(m_assembler.jCC(cond));
     1259#else
     1260        return branchTest32(cond, reg, mask);
     1261#endif
     1262    }
     1263
     1264    Jump branchTestPtr(Condition cond, RegisterID reg, Imm32 mask = Imm32(-1))
     1265    {
     1266#if PLATFORM(X86_64)
     1267        // if we are only interested in the low seven bits, this can be tested with a testb
     1268        if (mask.m_value == -1)
     1269            m_assembler.testq_rr(reg, reg);
     1270        else if ((mask.m_value & ~0x7f) == 0)
     1271            m_assembler.testb_i8r(mask.m_value, reg);
     1272        else
     1273            m_assembler.testq_i32r(mask.m_value, reg);
     1274        return Jump(m_assembler.jCC(cond));
     1275#else
     1276        return branchTest32(cond, reg, mask);
     1277#endif
     1278    }
     1279
     1280    Jump branchTestPtr(Condition cond, Address address, Imm32 mask = Imm32(-1))
     1281    {
     1282#if PLATFORM(X86_64)
     1283        if (mask.m_value == -1)
     1284            m_assembler.cmpq_im(0, address.offset, address.base);
     1285        else
     1286            m_assembler.testq_i32m(mask.m_value, address.offset, address.base);
     1287        return Jump(m_assembler.jCC(cond));
     1288#else
     1289        return branchTest32(cond, address, mask);
     1290#endif
     1291    }
     1292
     1293    Jump branchTestPtr(Condition cond, BaseIndex address, Imm32 mask = Imm32(-1))
     1294    {
     1295#if PLATFORM(X86_64)
     1296        if (mask.m_value == -1)
     1297            m_assembler.cmpq_im(0, address.offset, address.base, address.index, address.scale);
     1298        else
     1299            m_assembler.testq_i32m(mask.m_value, address.offset, address.base, address.index, address.scale);
     1300        return Jump(m_assembler.jCC(cond));
     1301#else
     1302        return branchTest32(cond, address, mask);
     1303#endif
     1304    }
     1305
     1306    Jump branchTest32(Condition cond, RegisterID reg, RegisterID mask)
     1307    {
     1308        ASSERT((cond == Zero) || (cond == NonZero));
     1309        m_assembler.testl_rr(reg, mask);
     1310        return Jump(m_assembler.jCC(cond));
     1311    }
     1312
     1313    Jump branchTest32(Condition cond, RegisterID reg, Imm32 mask = Imm32(-1))
     1314    {
     1315        ASSERT((cond == Zero) || (cond == NonZero));
    11161316        // if we are only interested in the low seven bits, this can be tested with a testb
    11171317        if (mask.m_value == -1)
    … …  
    11211321        else
    11221322            m_assembler.testl_i32r(mask.m_value, reg);
    1123     }
    1124 
    1125     void testImm32(Address address, Imm32 mask)
    1126     {
     1323        return Jump(m_assembler.jCC(cond));
     1324    }
     1325
     1326    Jump branchTest32(Condition cond, Address address, Imm32 mask = Imm32(-1))
     1327    {
     1328        ASSERT((cond == Zero) || (cond == NonZero));
    11271329        if (mask.m_value == -1)
    11281330            m_assembler.cmpl_im(0, address.offset, address.base);
    11291331        else
    11301332            m_assembler.testl_i32m(mask.m_value, address.offset, address.base);
    1131     }
    1132 
    1133     void testImm32(BaseIndex address, Imm32 mask)
    1134     {
     1333        return Jump(m_assembler.jCC(cond));
     1334    }
     1335
     1336    Jump branchTest32(Condition cond, BaseIndex address, Imm32 mask = Imm32(-1))
     1337    {
     1338        ASSERT((cond == Zero) || (cond == NonZero));
    11351339        if (mask.m_value == -1)
    11361340            m_assembler.cmpl_im(0, address.offset, address.base, address.index, address.scale);
    11371341        else
    11381342            m_assembler.testl_i32m(mask.m_value, address.offset, address.base, address.index, address.scale);
    1139     }
    1140 
    1141 #if PLATFORM(X86_64)
    1142     void compareImm64ForBranch(RegisterID left, int32_t right)
    1143     {
    1144         m_assembler.cmpq_ir(right, left);
    1145     }
    1146 
    1147     void compareImm64ForBranchEquality(RegisterID reg, int32_t imm)
    1148     {
    1149         if (!imm)
    1150             m_assembler.testq_rr(reg, reg);
    1151         else
    1152             m_assembler.cmpq_ir(imm, reg);
    1153     }
    1154 
    1155     void testImm64(RegisterID reg, Imm32 mask)
    1156     {
    1157         // if we are only interested in the low seven bits, this can be tested with a testb
    1158         if (mask.m_value == -1)
    1159             m_assembler.testq_rr(reg, reg);
    1160         else if ((mask.m_value & ~0x7f) == 0)
    1161             m_assembler.testb_i8r(mask.m_value, reg);
    1162         else
    1163             m_assembler.testq_i32r(mask.m_value, reg);
    1164     }
    1165 
    1166     void testImm64(Address address, Imm32 mask)
    1167     {
    1168         if (mask.m_value == -1)
    1169             m_assembler.cmpq_im(0, address.offset, address.base);
    1170         else
    1171             m_assembler.testq_i32m(mask.m_value, address.offset, address.base);
    1172     }
    1173 
    1174     void testImm64(BaseIndex address, Imm32 mask)
    1175     {
    1176         if (mask.m_value == -1)
    1177             m_assembler.cmpq_im(0, address.offset, address.base, address.index, address.scale);
    1178         else
    1179             m_assembler.testq_i32m(mask.m_value, address.offset, address.base, address.index, address.scale);
    1180     }
    1181 #endif
    1182 
    1183 public:
    1184     Jump ja32(RegisterID left, Imm32 right)
    1185     {
    1186         compareImm32ForBranch(left, right.m_value);
    1187         return Jump(m_assembler.ja());
    1188     }
    1189    
    1190     Jump jaePtr(RegisterID left, RegisterID right)
    1191     {
    1192 #if PLATFORM(X86_64)
    1193         m_assembler.cmpq_rr(right, left);
    1194         return Jump(m_assembler.jae());
    1195 #else
    1196         return jae32(left, right);
    1197 #endif
    1198     }
    1199 
    1200     Jump jaePtr(RegisterID reg, ImmPtr ptr)
    1201     {
    1202 #if PLATFORM(X86_64)
    1203         intptr_t imm = ptr.asIntptr();
    1204         if (CAN_SIGN_EXTEND_32_64(imm)) {
    1205             compareImm64ForBranch(reg, imm);
    1206             return Jump(m_assembler.jae());
    1207         } else {
    1208             move(ptr, scratchRegister);
    1209             return jaePtr(reg, scratchRegister);
    1210         }
    1211 #else
    1212         return jae32(reg, Imm32(ptr));
    1213 #endif
    1214     }
    1215 
    1216     Jump jae32(RegisterID left, RegisterID right)
    1217     {
    1218         m_assembler.cmpl_rr(right, left);
    1219         return Jump(m_assembler.jae());
    1220     }
    1221 
    1222     Jump jae32(RegisterID left, Imm32 right)
    1223     {
    1224         compareImm32ForBranch(left, right.m_value);
    1225         return Jump(m_assembler.jae());
    1226     }
    1227    
    1228     Jump jae32(RegisterID left, Address right)
    1229     {
    1230         m_assembler.cmpl_mr(right.offset, right.base, left);
    1231         return Jump(m_assembler.jae());
    1232     }
    1233    
    1234     Jump jae32(Address left, RegisterID right)
    1235     {
    1236         m_assembler.cmpl_rm(right, left.offset, left.base);
    1237         return Jump(m_assembler.jae());
    1238     }
    1239    
    1240     Jump jbPtr(RegisterID left, RegisterID right)
    1241     {
    1242 #if PLATFORM(X86_64)
    1243         m_assembler.cmpq_rr(right, left);
    1244         return Jump(m_assembler.jb());
    1245 #else
    1246         return jb32(left, right);
    1247 #endif
    1248     }
    1249 
    1250     Jump jbPtr(RegisterID reg, ImmPtr ptr)
    1251     {
    1252 #if PLATFORM(X86_64)
    1253         intptr_t imm = ptr.asIntptr();
    1254         if (CAN_SIGN_EXTEND_32_64(imm)) {
    1255             compareImm64ForBranch(reg, imm);
    1256             return Jump(m_assembler.jb());
    1257         } else {
    1258             move(ptr, scratchRegister);
    1259             return jbPtr(reg, scratchRegister);
    1260         }
    1261 #else
    1262         return jb32(reg, Imm32(ptr));
    1263 #endif
    1264     }
    1265 
    1266     Jump jb32(RegisterID left, RegisterID right)
    1267     {
    1268         m_assembler.cmpl_rr(right, left);
    1269         return Jump(m_assembler.jb());
    1270     }
    1271 
    1272     Jump jb32(RegisterID left, Imm32 right)
    1273     {
    1274         compareImm32ForBranch(left, right.m_value);
    1275         return Jump(m_assembler.jb());
    1276     }
    1277    
    1278     Jump jb32(RegisterID left, Address right)
    1279     {
    1280         m_assembler.cmpl_mr(right.offset, right.base, left);
    1281         return Jump(m_assembler.jb());
    1282     }
    1283    
    1284     Jump jePtr(RegisterID op1, RegisterID op2)
    1285     {
    1286 #if PLATFORM(X86_64)
    1287         m_assembler.cmpq_rr(op1, op2);
    1288         return Jump(m_assembler.je());
    1289 #else
    1290         return je32(op1, op2);
    1291 #endif
    1292     }
    1293 
    1294     Jump jePtr(RegisterID reg, Address address)
    1295     {
    1296 #if PLATFORM(X86_64)
    1297         m_assembler.cmpq_rm(reg, address.offset, address.base);
    1298 #else
    1299         m_assembler.cmpl_rm(reg, address.offset, address.base);
    1300 #endif
    1301         return Jump(m_assembler.je());
    1302     }
    1303 
    1304     Jump jePtr(RegisterID reg, ImmPtr ptr)
    1305     {
    1306 #if PLATFORM(X86_64)
    1307         intptr_t imm = ptr.asIntptr();
    1308         if (CAN_SIGN_EXTEND_32_64(imm)) {
    1309             compareImm64ForBranchEquality(reg, imm);
    1310             return Jump(m_assembler.je());
    1311         } else {
    1312             move(ptr, scratchRegister);
    1313             return jePtr(scratchRegister, reg);
    1314         }
    1315 #else
    1316         return je32(reg, Imm32(ptr));
    1317 #endif
    1318     }
    1319 
    1320     Jump jePtr(Address address, ImmPtr imm)
    1321     {
    1322 #if PLATFORM(X86_64)
    1323         move(imm, scratchRegister);
    1324         return jePtr(scratchRegister, address);
    1325 #else
    1326         return je32(address, Imm32(imm));
    1327 #endif
    1328     }
    1329 
    1330     Jump je32(RegisterID op1, RegisterID op2)
    1331     {
    1332         m_assembler.cmpl_rr(op1, op2);
    1333         return Jump(m_assembler.je());
    1334     }
    1335    
    1336     Jump je32(Address op1, RegisterID op2)
    1337     {
    1338         m_assembler.cmpl_mr(op1.offset, op1.base, op2);
    1339         return Jump(m_assembler.je());
    1340     }
    1341    
    1342     Jump je32(RegisterID reg, Imm32 imm)
    1343     {
    1344         compareImm32ForBranchEquality(reg, imm.m_value);
    1345         return Jump(m_assembler.je());
    1346     }
    1347 
    1348     Jump je32(Address address, Imm32 imm)
    1349     {
    1350         compareImm32ForBranchEquality(address, imm.m_value);
    1351         return Jump(m_assembler.je());
    1352     }
    1353    
    1354     Jump je16(RegisterID op1, BaseIndex op2)
    1355     {
    1356         m_assembler.cmpw_rm(op1, op2.offset, op2.base, op2.index, op2.scale);
    1357         return Jump(m_assembler.je());
    1358     }
    1359    
    1360     Jump jg32(RegisterID left, RegisterID right)
    1361     {
    1362         m_assembler.cmpl_rr(right, left);
    1363         return Jump(m_assembler.jg());
    1364     }
    1365 
    1366     Jump jg32(RegisterID reg, Address address)
    1367     {
    1368         m_assembler.cmpl_mr(address.offset, address.base, reg);
    1369         return Jump(m_assembler.jg());
    1370     }
    1371 
    1372     Jump jgePtr(RegisterID left, RegisterID right)
    1373     {
    1374 #if PLATFORM(X86_64)
    1375         m_assembler.cmpq_rr(right, left);
    1376         return Jump(m_assembler.jge());
    1377 #else
    1378         return jge32(left, right);
    1379 #endif
    1380     }
    1381 
    1382     Jump jgePtr(RegisterID reg, ImmPtr ptr)
    1383     {
    1384 #if PLATFORM(X86_64)
    1385         intptr_t imm = ptr.asIntptr();
    1386         if (CAN_SIGN_EXTEND_32_64(imm)) {
    1387             compareImm64ForBranch(reg, imm);
    1388             return Jump(m_assembler.jge());
    1389         } else {
    1390             move(ptr, scratchRegister);
    1391             return jgePtr(reg, scratchRegister);
    1392         }
    1393 #else
    1394         return jge32(reg, Imm32(ptr));
    1395 #endif
    1396     }
    1397 
    1398     Jump jge32(RegisterID left, RegisterID right)
    1399     {
    1400         m_assembler.cmpl_rr(right, left);
    1401         return Jump(m_assembler.jge());
    1402     }
    1403 
    1404     Jump jge32(RegisterID left, Imm32 right)
    1405     {
    1406         compareImm32ForBranch(left, right.m_value);
    1407         return Jump(m_assembler.jge());
    1408     }
    1409 
    1410     Jump jlPtr(RegisterID left, RegisterID right)
    1411     {
    1412 #if PLATFORM(X86_64)
    1413         m_assembler.cmpq_rr(right, left);
    1414         return Jump(m_assembler.jl());
    1415 #else
    1416         return jl32(left, right);
    1417 #endif
    1418     }
    1419 
    1420     Jump jlPtr(RegisterID reg, ImmPtr ptr)
    1421     {
    1422 #if PLATFORM(X86_64)
    1423         intptr_t imm = ptr.asIntptr();
    1424         if (CAN_SIGN_EXTEND_32_64(imm)) {
    1425             compareImm64ForBranch(reg, imm);
    1426             return Jump(m_assembler.jl());
    1427         } else {
    1428             move(ptr, scratchRegister);
    1429             return jlPtr(reg, scratchRegister);
    1430         }
    1431 #else
    1432         return jl32(reg, Imm32(ptr));
    1433 #endif
    1434     }
    1435 
    1436     Jump jl32(RegisterID left, RegisterID right)
    1437     {
    1438         m_assembler.cmpl_rr(right, left);
    1439         return Jump(m_assembler.jl());
    1440     }
    1441    
    1442     Jump jl32(RegisterID left, Imm32 right)
    1443     {
    1444         compareImm32ForBranch(left, right.m_value);
    1445         return Jump(m_assembler.jl());
    1446     }
    1447 
    1448     Jump jlePtr(RegisterID left, RegisterID right)
    1449     {
    1450 #if PLATFORM(X86_64)
    1451         m_assembler.cmpq_rr(right, left);
    1452         return Jump(m_assembler.jle());
    1453 #else
    1454         return jle32(left, right);
    1455 #endif
    1456     }
    1457 
    1458     Jump jlePtr(RegisterID reg, ImmPtr ptr)
    1459     {
    1460 #if PLATFORM(X86_64)
    1461         intptr_t imm = ptr.asIntptr();
    1462         if (CAN_SIGN_EXTEND_32_64(imm)) {
    1463             compareImm64ForBranch(reg, imm);
    1464             return Jump(m_assembler.jle());
    1465         } else {
    1466             move(ptr, scratchRegister);
    1467             return jlePtr(reg, scratchRegister);
    1468         }
    1469 #else
    1470         return jle32(reg, Imm32(ptr));
    1471 #endif
    1472     }
    1473 
    1474     Jump jle32(RegisterID left, RegisterID right)
    1475     {
    1476         m_assembler.cmpl_rr(right, left);
    1477         return Jump(m_assembler.jle());
    1478     }
    1479    
    1480     Jump jle32(RegisterID left, Imm32 right)
    1481     {
    1482         compareImm32ForBranch(left, right.m_value);
    1483         return Jump(m_assembler.jle());
    1484     }
    1485 
    1486     Jump jnePtr(RegisterID op1, RegisterID op2)
    1487     {
    1488 #if PLATFORM(X86_64)
    1489         m_assembler.cmpq_rr(op1, op2);
    1490         return Jump(m_assembler.jne());
    1491 #else
    1492         return jne32(op1, op2);
    1493 #endif
    1494     }
    1495 
    1496     Jump jnePtr(RegisterID reg, Address address)
    1497     {
    1498 #if PLATFORM(X86_64)
    1499         m_assembler.cmpq_rm(reg, address.offset, address.base);
    1500 #else
    1501         m_assembler.cmpl_rm(reg, address.offset, address.base);
    1502 #endif
    1503         return Jump(m_assembler.jne());
    1504     }
    1505 
    1506     Jump jnePtr(RegisterID reg, AbsoluteAddress address)
    1507     {
    1508 #if PLATFORM(X86_64)
    1509         move(ImmPtr(address.m_ptr), scratchRegister);
    1510         return jnePtr(reg, Address(scratchRegister));
    1511 #else
    1512         m_assembler.cmpl_rm(reg, address.m_ptr);
    1513         return Jump(m_assembler.jne());
    1514 #endif
    1515     }
    1516 
    1517     Jump jnePtr(RegisterID reg, ImmPtr ptr)
    1518     {
    1519 #if PLATFORM(X86_64)
    1520         intptr_t imm = ptr.asIntptr();
    1521         if (CAN_SIGN_EXTEND_32_64(imm)) {
    1522             compareImm64ForBranchEquality(reg, imm);
    1523             return Jump(m_assembler.jne());
    1524         } else {
    1525             move(ptr, scratchRegister);
    1526             return jnePtr(scratchRegister, reg);
    1527         }
    1528 #else
    1529         return jne32(reg, Imm32(ptr));
    1530 #endif
    1531     }
    1532 
    1533     Jump jnePtr(Address address, ImmPtr imm)
    1534     {
    1535 #if PLATFORM(X86_64)
    1536         move(imm, scratchRegister);
    1537         return jnePtr(scratchRegister, address);
    1538 #else
    1539         return jne32(address, Imm32(imm));
    1540 #endif
    1541     }
    1542 
    1543 #if !PLATFORM(X86_64)
    1544     Jump jnePtr(AbsoluteAddress address, ImmPtr imm)
    1545     {
    1546         m_assembler.cmpl_im(imm.asIntptr(), address.m_ptr);
    1547         return Jump(m_assembler.jne());
    1548     }
    1549 #endif
    1550 
    1551     Jump jnePtrWithPatch(RegisterID reg, DataLabelPtr& dataLabel, ImmPtr initialValue = ImmPtr(0))
    1552     {
    1553 #if PLATFORM(X86_64)
    1554         m_assembler.movq_i64r(initialValue.asIntptr(), scratchRegister);
    1555         dataLabel = DataLabelPtr(this);
    1556         return jnePtr(scratchRegister, reg);
    1557 #else
    1558         m_assembler.cmpl_ir_force32(initialValue.asIntptr(), reg);
    1559         dataLabel = DataLabelPtr(this);
    1560         return Jump(m_assembler.jne());
    1561 #endif
    1562     }
    1563 
    1564     Jump jnePtrWithPatch(Address address, DataLabelPtr& dataLabel, ImmPtr initialValue = ImmPtr(0))
    1565     {
    1566 #if PLATFORM(X86_64)
    1567         m_assembler.movq_i64r(initialValue.asIntptr(), scratchRegister);
    1568         dataLabel = DataLabelPtr(this);
    1569         return jnePtr(scratchRegister, address);
    1570 #else
    1571         m_assembler.cmpl_im_force32(initialValue.asIntptr(), address.offset, address.base);
    1572         dataLabel = DataLabelPtr(this);
    1573         return Jump(m_assembler.jne());
    1574 #endif
    1575     }
    1576 
    1577     Jump jne32(RegisterID op1, RegisterID op2)
    1578     {
    1579         m_assembler.cmpl_rr(op1, op2);
    1580         return Jump(m_assembler.jne());
    1581     }
    1582 
    1583     Jump jne32(RegisterID reg, Imm32 imm)
    1584     {
    1585         compareImm32ForBranchEquality(reg, imm.m_value);
    1586         return Jump(m_assembler.jne());
    1587     }
    1588 
    1589     Jump jne32(Address address, Imm32 imm)
    1590     {
    1591         compareImm32ForBranchEquality(address, imm.m_value);
    1592         return Jump(m_assembler.jne());
    1593     }
    1594    
    1595     Jump jne32(Address address, RegisterID reg)
    1596     {
    1597         m_assembler.cmpl_rm(reg, address.offset, address.base);
    1598         return Jump(m_assembler.jne());
    1599     }
    1600    
    1601     Jump jnzPtr(RegisterID reg, RegisterID mask)
    1602     {
    1603 #if PLATFORM(X86_64)
    1604         m_assembler.testq_rr(reg, mask);
    1605         return Jump(m_assembler.jne());
    1606 #else
    1607         return jnz32(reg, mask);
    1608 #endif
    1609     }
    1610 
    1611     Jump jnzPtr(RegisterID reg, Imm32 mask = Imm32(-1))
    1612     {
    1613 #if PLATFORM(X86_64)
    1614         testImm64(reg, mask);
    1615         return Jump(m_assembler.jne());
    1616 #else
    1617         return jnz32(reg, mask);
    1618 #endif
    1619     }
    1620 
    1621     Jump jnzPtr(RegisterID reg, ImmPtr mask)
    1622     {
    1623 #if PLATFORM(X86_64)
    1624         move(mask, scratchRegister);
    1625         m_assembler.testq_rr(scratchRegister, reg);
    1626         return Jump(m_assembler.jne());
    1627 #else
    1628         return jnz32(reg, Imm32(mask));
    1629 #endif
    1630     }
    1631 
    1632     Jump jnzPtr(Address address, Imm32 mask = Imm32(-1))
    1633     {
    1634 #if PLATFORM(X86_64)
    1635         testImm64(address, mask);
    1636         return Jump(m_assembler.jne());
    1637 #else
    1638         return jnz32(address, mask);
    1639 #endif
    1640     }
    1641 
    1642     Jump jnz32(RegisterID reg, RegisterID mask)
    1643     {
    1644         m_assembler.testl_rr(reg, mask);
    1645         return Jump(m_assembler.jne());
    1646     }
    1647 
    1648     Jump jnz32(RegisterID reg, Imm32 mask = Imm32(-1))
    1649     {
    1650         testImm32(reg, mask);
    1651         return Jump(m_assembler.jne());
    1652     }
    1653 
    1654     Jump jnz32(Address address, Imm32 mask = Imm32(-1))
    1655     {
    1656         testImm32(address, mask);
    1657         return Jump(m_assembler.jne());
    1658     }
    1659 
    1660     Jump jzPtr(RegisterID reg, RegisterID mask)
    1661     {
    1662 #if PLATFORM(X86_64)
    1663         m_assembler.testq_rr(reg, mask);
    1664         return Jump(m_assembler.je());
    1665 #else
    1666         return jz32(reg, mask);
    1667 #endif
    1668     }
    1669 
    1670     Jump jzPtr(RegisterID reg, Imm32 mask = Imm32(-1))
    1671     {
    1672 #if PLATFORM(X86_64)
    1673         testImm64(reg, mask);
    1674         return Jump(m_assembler.je());
    1675 #else
    1676         return jz32(reg, mask);
    1677 #endif
    1678     }
    1679 
    1680     Jump jzPtr(RegisterID reg, ImmPtr mask)
    1681     {
    1682 #if PLATFORM(X86_64)
    1683         move(mask, scratchRegister);
    1684         m_assembler.testq_rr(scratchRegister, reg);
    1685         return Jump(m_assembler.je());
    1686 #else
    1687         return jz32(reg, Imm32(mask));
    1688 #endif
    1689     }
    1690 
    1691     Jump jzPtr(Address address, Imm32 mask = Imm32(-1))
    1692     {
    1693 #if PLATFORM(X86_64)
    1694         testImm64(address, mask);
    1695         return Jump(m_assembler.je());
    1696 #else
    1697         return jz32(address, mask);
    1698 #endif
    1699     }
    1700 
    1701     Jump jzPtr(BaseIndex address, Imm32 mask = Imm32(-1))
    1702     {
    1703 #if PLATFORM(X86_64)
    1704         testImm64(address, mask);
    1705         return Jump(m_assembler.je());
    1706 #else
    1707         return jz32(address, mask);
    1708 #endif
    1709     }
    1710 
    1711     Jump jz32(RegisterID reg, RegisterID mask)
    1712     {
    1713         m_assembler.testl_rr(reg, mask);
    1714         return Jump(m_assembler.je());
    1715     }
    1716 
    1717     Jump jz32(RegisterID reg, Imm32 mask = Imm32(-1))
    1718     {
    1719         testImm32(reg, mask);
    1720         return Jump(m_assembler.je());
    1721     }
    1722 
    1723     Jump jz32(Address address, Imm32 mask = Imm32(-1))
    1724     {
    1725         testImm32(address, mask);
    1726         return Jump(m_assembler.je());
    1727     }
    1728 
    1729     Jump jz32(BaseIndex address, Imm32 mask = Imm32(-1))
    1730     {
    1731         testImm32(address, mask);
    1732         return Jump(m_assembler.je());
     1343        return Jump(m_assembler.jCC(cond));
    17331344    }
    17341345
    … …  
    17591370    //     jne32(reg1, reg2).linkTo(topOfLoop);
    17601371
    1761     void jae32(RegisterID left, Address right, Label target)
    1762     {
    1763         jae32(left, right).linkTo(target, this);
    1764     }
    1765 
    1766     void je32(RegisterID op1, Imm32 imm, Label target)
    1767     {
    1768         je32(op1, imm).linkTo(target, this);
    1769     }
    1770 
    1771     void je16(RegisterID op1, BaseIndex op2, Label target)
    1772     {
    1773         je16(op1, op2).linkTo(target, this);
    1774     }
    1775    
    1776     void jl32(RegisterID left, Imm32 right, Label target)
    1777     {
    1778         jl32(left, right).linkTo(target, this);
    1779     }
    1780    
    1781     void jle32(RegisterID left, RegisterID right, Label target)
    1782     {
    1783         jle32(left, right).linkTo(target, this);
    1784     }
    1785    
    1786     void jnePtr(RegisterID op1, ImmPtr imm, Label target)
    1787     {
    1788         jnePtr(op1, imm).linkTo(target, this);
    1789     }
    1790 
    1791     void jne32(RegisterID op1, RegisterID op2, Label target)
    1792     {
    1793         jne32(op1, op2).linkTo(target, this);
    1794     }
    1795 
    1796     void jne32(RegisterID op1, Imm32 imm, Label target)
    1797     {
    1798         jne32(op1, imm).linkTo(target, this);
    1799     }
    1800 
    1801     void jzPtr(RegisterID reg, Label target)
    1802     {
    1803         jzPtr(reg).linkTo(target, this);
     1372    void branchPtr(Condition cond, RegisterID op1, ImmPtr imm, Label target)
     1373    {
     1374        branchPtr(cond, op1, imm).linkTo(target, this);
     1375    }
     1376
     1377    void branch32(Condition cond, RegisterID op1, RegisterID op2, Label target)
     1378    {
     1379        branch32(cond, op1, op2).linkTo(target, this);
     1380    }
     1381
     1382    void branch32(Condition cond, RegisterID op1, Imm32 imm, Label target)
     1383    {
     1384        branch32(cond, op1, imm).linkTo(target, this);
     1385    }
     1386
     1387    void branch32(Condition cond, RegisterID left, Address right, Label target)
     1388    {
     1389        branch32(cond, left, right).linkTo(target, this);
     1390    }
     1391
     1392    void branch16(Condition cond, BaseIndex left, RegisterID right, Label target)
     1393    {
     1394        branch16(cond, left, right).linkTo(target, this);
     1395    }
     1396   
     1397    void branchTestPtr(Condition cond, RegisterID reg, Label target)
     1398    {
     1399        branchTestPtr(cond, reg).linkTo(target, this);
    18041400    }
    18051401
    … …  
    18311427    //   operation caused an overflow to occur.
    18321428
    1833     Jump jnzSubPtr(Imm32 imm, RegisterID dest)
    1834     {
     1429    Jump branchAddPtr(Condition cond, RegisterID src, RegisterID dest)
     1430    {
     1431        ASSERT((cond == Overflow) || (cond == Zero) || (cond == NonZero));
     1432        addPtr(src, dest);
     1433        return Jump(m_assembler.jCC(cond));
     1434    }
     1435   
     1436    Jump branchAdd32(Condition cond, RegisterID src, RegisterID dest)
     1437    {
     1438        ASSERT((cond == Overflow) || (cond == Zero) || (cond == NonZero));
     1439        add32(src, dest);
     1440        return Jump(m_assembler.jCC(cond));
     1441    }
     1442   
     1443    Jump branchAdd32(Condition cond, Imm32 imm, RegisterID dest)
     1444    {
     1445        ASSERT((cond == Overflow) || (cond == Zero) || (cond == NonZero));
     1446        add32(imm, dest);
     1447        return Jump(m_assembler.jCC(cond));
     1448    }
     1449   
     1450    Jump branchMul32(Condition cond, RegisterID src, RegisterID dest)
     1451    {
     1452        ASSERT((cond == Overflow) || (cond == Zero) || (cond == NonZero));
     1453        mul32(src, dest);
     1454        return Jump(m_assembler.jCC(cond));
     1455    }
     1456   
     1457    Jump branchMul32(Condition cond, Imm32 imm, RegisterID src, RegisterID dest)
     1458    {
     1459        ASSERT((cond == Overflow) || (cond == Zero) || (cond == NonZero));
     1460        mul32(imm, src, dest);
     1461        return Jump(m_assembler.jCC(cond));
     1462    }
     1463   
     1464    Jump branchSubPtr(Condition cond, Imm32 imm, RegisterID dest)
     1465    {
     1466        ASSERT((cond == Overflow) || (cond == Zero) || (cond == NonZero));
    18351467        subPtr(imm, dest);
    1836         return Jump(m_assembler.jne());
    1837     }
    1838    
    1839     Jump jnzSub32(Imm32 imm, RegisterID dest)
    1840     {
     1468        return Jump(m_assembler.jCC(cond));
     1469    }
     1470   
     1471    Jump branchSub32(Condition cond, RegisterID src, RegisterID dest)
     1472    {
     1473        ASSERT((cond == Overflow) || (cond == Zero) || (cond == NonZero));
     1474        sub32(src, dest);
     1475        return Jump(m_assembler.jCC(cond));
     1476    }
     1477   
     1478    Jump branchSub32(Condition cond, Imm32 imm, RegisterID dest)
     1479    {
     1480        ASSERT((cond == Overflow) || (cond == Zero) || (cond == NonZero));
    18411481        sub32(imm, dest);
    1842         return Jump(m_assembler.jne());
    1843     }
    1844    
    1845     Jump joAddPtr(RegisterID src, RegisterID dest)
    1846     {
    1847         addPtr(src, dest);
    1848         return Jump(m_assembler.jo());
    1849     }
    1850    
    1851     Jump joAdd32(RegisterID src, RegisterID dest)
    1852     {
    1853         add32(src, dest);
    1854         return Jump(m_assembler.jo());
    1855     }
    1856    
    1857     Jump joAdd32(Imm32 imm, RegisterID dest)
    1858     {
    1859         add32(imm, dest);
    1860         return Jump(m_assembler.jo());
    1861     }
    1862    
    1863     Jump joMul32(RegisterID src, RegisterID dest)
    1864     {
    1865         mul32(src, dest);
    1866         return Jump(m_assembler.jo());
    1867     }
    1868    
    1869     Jump joMul32(Imm32 imm, RegisterID src, RegisterID dest)
    1870     {
    1871         mul32(imm, src, dest);
    1872         return Jump(m_assembler.jo());
    1873     }
    1874    
    1875     Jump joSub32(RegisterID src, RegisterID dest)
    1876     {
    1877         sub32(src, dest);
    1878         return Jump(m_assembler.jo());
    1879     }
    1880    
    1881     Jump joSub32(Imm32 imm, RegisterID dest)
    1882     {
    1883         sub32(imm, dest);
    1884         return Jump(m_assembler.jo());
    1885     }
    1886    
    1887     Jump jzSubPtr(Imm32 imm, RegisterID dest)
    1888     {
    1889         subPtr(imm, dest);
    1890         return Jump(m_assembler.je());
    1891     }
    1892    
    1893     Jump jzSub32(Imm32 imm, RegisterID dest)
    1894     {
    1895         sub32(imm, dest);
    1896         return Jump(m_assembler.je());
     1482        return Jump(m_assembler.jCC(cond));
    18971483    }
    18981484   
    … …  
    19661552    }
    19671553
    1968     void sete32(RegisterID src, RegisterID srcDest)
    1969     {
    1970         m_assembler.cmpl_rr(srcDest, src);
    1971         m_assembler.sete_r(srcDest);
    1972         m_assembler.movzbl_rr(srcDest, srcDest);
    1973     }
    1974 
    1975     void sete32(Imm32 imm, RegisterID srcDest)
    1976     {
    1977         compareImm32ForBranchEquality(srcDest, imm.m_value);
    1978         m_assembler.sete_r(srcDest);
    1979         m_assembler.movzbl_rr(srcDest, srcDest);
    1980     }
    1981 
    1982     void setne32(RegisterID src, RegisterID srcDest)
    1983     {
    1984         m_assembler.cmpl_rr(srcDest, src);
    1985         m_assembler.setne_r(srcDest);
    1986         m_assembler.movzbl_rr(srcDest, srcDest);
    1987     }
    1988 
    1989     void setne32(Imm32 imm, RegisterID srcDest)
    1990     {
    1991         compareImm32ForBranchEquality(srcDest, imm.m_value);
    1992         m_assembler.setne_r(srcDest);
    1993         m_assembler.movzbl_rr(srcDest, srcDest);
     1554    void set32(Condition cond, RegisterID left, RegisterID right, RegisterID dest)
     1555    {
     1556        m_assembler.cmpl_rr(right, left);
     1557        m_assembler.setCC_r(cond, dest);
     1558        m_assembler.movzbl_rr(dest, dest);
     1559    }
     1560
     1561    void set32(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
     1562    {
     1563        if (((cond == Equal) || (cond == NotEqual)) && !right.m_value)
     1564            m_assembler.testl_rr(left, left);
     1565        else
     1566            m_assembler.cmpl_ir(right.m_value, left);
     1567        m_assembler.setCC_r(cond, dest);
     1568        m_assembler.movzbl_rr(dest, dest);
    19941569    }
    19951570
    … …  
    19981573    // dest-src, operations always have a dest? ... possibly not true, considering
    19991574    // asm ops like test, or pseudo ops like pop().
    2000     void setnz32(Address address, Imm32 mask, RegisterID dest)
    2001     {
    2002         testImm32(address, mask);
    2003         m_assembler.setnz_r(dest);
     1575    void setTest32(Condition cond, Address address, Imm32 mask, RegisterID dest)
     1576    {
     1577        if (mask.m_value == -1)
     1578            m_assembler.cmpl_im(0, address.offset, address.base);
     1579        else
     1580            m_assembler.testl_i32m(mask.m_value, address.offset, address.base);
     1581        m_assembler.setCC_r(cond, dest);
    20041582        m_assembler.movzbl_rr(dest, dest);
    20051583    }
    2006 
    2007     void setz32(Address address, Imm32 mask, RegisterID dest)
    2008     {
    2009         testImm32(address, mask);
    2010         m_assembler.setz_r(dest);
    2011         m_assembler.movzbl_rr(dest, dest);
    2012     }
    20131584};
    20141585
Note: See TracChangeset for help on using the changeset viewer.