Lines Matching refs:__
86 #define __ assembler->
117 __ movsd(temp, input.AsFpuRegister<XmmRegister>());
118 __ movd(output.AsRegisterPairLow<Register>(), temp);
119 __ psrlq(temp, Immediate(32));
120 __ movd(output.AsRegisterPairHigh<Register>(), temp);
122 __ movd(output.AsRegister<Register>(), input.AsFpuRegister<XmmRegister>());
133 __ movd(temp1, input.AsRegisterPairLow<Register>());
134 __ movd(temp2, input.AsRegisterPairHigh<Register>());
135 __ punpckldq(temp1, temp2);
136 __ movsd(output.AsFpuRegister<XmmRegister>(), temp1);
138 __ movd(output.AsFpuRegister<XmmRegister>(), input.AsRegister<Register>());
202 __ bswapl(out);
203 __ sarl(out, Immediate(16));
206 __ bswapl(out);
237 __ movl(output_lo, input_hi);
238 __ movl(output_hi, input_lo);
239 __ bswapl(output_lo);
240 __ bswapl(output_hi);
286 __ movsd(temp, codegen->LiteralInt64Address(INT64_C(0x7FFFFFFFFFFFFFFF), constant_area));
287 __ andpd(output.AsFpuRegister<XmmRegister>(), temp);
289 __ movss(temp, codegen->LiteralInt32Address(INT32_C(0x7FFFFFFF), constant_area));
290 __ andps(output.AsFpuRegister<XmmRegister>(), temp);
295 __ subl(ESP, Immediate(8));
296 __ pushl(Immediate(0x7FFFFFFF));
297 __ pushl(Immediate(0xFFFFFFFF));
298 __ andpd(output.AsFpuRegister<XmmRegister>(), Address(ESP, 0));
300 __ subl(ESP, Immediate(12));
301 __ pushl(Immediate(0x7FFFFFFF));
302 __ andps(output.AsFpuRegister<XmmRegister>(), Address(ESP, 0));
304 __ addl(ESP, Immediate(16));
341 __ cdq();
344 __ xorl(EAX, EDX);
347 __ subl(EAX, EDX);
371 __ movl(temp, input_hi);
372 __ sarl(temp, Immediate(31));
375 __ movl(output_lo, temp);
376 __ movl(output_hi, temp);
379 __ xorl(output_lo, input_lo);
380 __ xorl(output_hi, input_hi);
383 __ subl(output_lo, temp);
384 __ sbbl(output_hi, temp);
440 __ ucomisd(out, op2);
442 __ ucomiss(out, op2);
445 __ j(Condition::kParityEven, &nan);
447 __ j(is_min ? Condition::kAbove : Condition::kBelow, &op2_label);
448 __ j(is_min ? Condition::kBelow : Condition::kAbove, &done);
453 __ orpd(out, op2);
455 __ orps(out, op2);
459 __ andpd(out, op2);
461 __ andps(out, op2);
464 __ jmp(&done);
467 __ Bind(&nan);
473 __ movsd(out, codegen->LiteralInt64Address(kDoubleNaN, constant_area));
475 __ movss(out, codegen->LiteralInt32Address(kFloatNaN, constant_area));
479 __ pushl(Immediate(kDoubleNaNHigh));
480 __ pushl(Immediate(kDoubleNaNLow));
481 __ movsd(out, Address(ESP, 0));
482 __ addl(ESP, Immediate(8));
484 __ pushl(Immediate(kFloatNaN));
485 __ movss(out, Address(ESP, 0));
486 __ addl(ESP, Immediate(4));
489 __ jmp(&done);
492 __ Bind(&op2_label);
494 __ movsd(out, op2);
496 __ movss(out, op2);
500 __ Bind(&done);
596 __ movl(temp, output_lo);
597 __ subl(temp, op2_lo);
600 __ movl(temp, output_hi);
601 __ sbbl(temp, op2_hi);
605 __ cmovl(cond, output_lo, op2_lo);
606 __ cmovl(cond, output_hi, op2_hi);
617 __ cmpl(out, op2);
619 __ cmovl(cond, out, op2);
740 __ roundsd(out, in, Immediate(round_mode));
814 __ movl(out, Immediate(bit_cast<int32_t, float>(0.5f)));
815 __ movd(inPlusPointFive, out);
818 __ addss(inPlusPointFive, in);
821 __ roundss(inPlusPointFive, inPlusPointFive, Immediate(1));
823 __ movl(out, Immediate(kPrimIntMax));
825 __ cvtsi2ss(maxInt, out);
828 __ comiss(inPlusPointFive, maxInt);
829 __ j(kAboveEqual, &done);
832 __ j(kUnordered, &nan);
835 __ cvttss2si(out, inPlusPointFive);
836 __ jmp(&done);
837 __ Bind(&nan);
840 __ xorl(out, out);
841 __ Bind(&done);
861 __ subl(ESP, Immediate(16));
862 __ cfi().AdjustCFAOffset(16);
865 __ movsd(Address(ESP, 0), XMM0);
869 __ movsd(Address(ESP, 8), XMM1);
873 __ fs()->call(Address::Absolute(GetThreadOffset<kX86WordSize>(entry)));
876 __ fstpl(Address(ESP, 0));
877 __ movsd(XMM0, Address(ESP, 0));
880 __ addl(ESP, Immediate(16));
881 __ cfi().AdjustCFAOffset(-16);
1065 __ cmpl(idx, Address(obj, count_offset));
1067 __ j(kAboveEqual, slow_path->GetEntryLabel());
1070 __ movzxw(out, Address(out, idx, ScaleFactor::TIMES_2, value_offset));
1072 __ Bind(slow_path->GetExitLabel());
1139 __ cmpl(Address(input, length_offset), length);
1140 __ j(kLess, slow_path->GetEntryLabel());
1143 __ movl(input_len, Address(input, length_offset));
1144 __ cmpl(input_len, Immediate(pos_const));
1145 __ j(kLess, slow_path->GetEntryLabel());
1148 __ leal(temp, Address(input_len, -pos_const));
1149 __ cmpl(temp, length);
1150 __ j(kLess, slow_path->GetEntryLabel());
1155 __ testl(pos_reg, pos_reg);
1156 __ j(kLess, slow_path->GetEntryLabel());
1159 __ cmpl(Address(input, length_offset), pos_reg);
1160 __ j(kLess, slow_path->GetEntryLabel());
1163 __ movl(temp, Address(input, length_offset));
1164 __ subl(temp, pos_reg);
1165 __ cmpl(temp, length);
1166 __ j(kLess, slow_path->GetEntryLabel());
1192 __ cmpl(src, dest);
1193 __ j(kEqual, slow_path->GetEntryLabel());
1196 __ testl(src, src);
1197 __ j(kEqual, slow_path->GetEntryLabel());
1200 __ testl(dest, dest);
1201 __ j(kEqual, slow_path->GetEntryLabel());
1206 __ cmpl(length.AsRegister<Register>(), length.AsRegister<Register>());
1207 __ j(kLess, slow_path->GetEntryLabel());
1212 __ movl(count, Immediate(length.GetConstant()->AsIntConstant()->GetValue()));
1214 __ movl(count, length.AsRegister<Register>());
1232 __ leal(src_base, Address(src, char_size * srcPos_const + data_offset));
1234 __ leal(src_base, Address(src, srcPos.AsRegister<Register>(),
1240 __ leal(dest_base, Address(dest, char_size * destPos_const + data_offset));
1242 __ leal(dest_base, Address(dest, destPos.AsRegister<Register>(),
1247 __ rep_movsw();
1249 __ Bind(slow_path->GetExitLabel());
1271 __ testl(argument, argument);
1274 __ j(kEqual, slow_path->GetEntryLabel());
1276 __ fs()->call(Address::Absolute(QUICK_ENTRYPOINT_OFFSET(kX86WordSize, pStringCompareTo)));
1277 __ Bind(slow_path->GetExitLabel());
1318 __ testl(arg, arg);
1319 __ j(kEqual, &return_false);
1327 __ movl(ecx, Address(str, class_offset));
1328 __ cmpl(ecx, Address(arg, class_offset));
1329 __ j(kNotEqual, &return_false);
1333 __ cmpl(str, arg);
1334 __ j(kEqual, &return_true);
1337 __ movl(ecx, Address(str, count_offset));
1339 __ cmpl(ecx, Address(arg, count_offset));
1340 __ j(kNotEqual, &return_false);
1342 __ jecxz(&return_true);
1345 __ leal(esi, Address(str, value_offset));
1346 __ leal(edi, Address(arg, value_offset));
1349 __ addl(ecx, Immediate(1));
1350 __ shrl(ecx, Immediate(1));
1357 __ repe_cmpsl();
1359 __ j(kNotEqual, &return_false);
1363 __ Bind(&return_true);
1364 __ movl(esi, Immediate(1));
1365 __ jmp(&end);
1368 __ Bind(&return_false);
1369 __ xorl(esi, esi);
1370 __ Bind(&end);
1430 __ jmp(slow_path->GetEntryLabel());
1431 __ Bind(slow_path->GetExitLabel());
1435 __ cmpl(search_value, Immediate(std::numeric_limits<uint16_t>::max()));
1438 __ j(kAbove, slow_path->GetEntryLabel());
1448 __ movl(string_length, Address(string_obj, count_offset));
1453 __ testl(string_length, string_length);
1454 __ j(kEqual, ¬_found_label);
1458 __ movl(counter, string_length);
1461 __ addl(string_obj, Immediate(value_offset));
1466 __ cmpl(start_index, string_length);
1467 __ j(kGreaterEqual, ¬_found_label);
1470 __ xorl(counter, counter);
1471 __ cmpl(start_index, Immediate(0));
1472 __ cmovl(kGreater, counter, start_index);
1475 __ leal(string_obj, Address(string_obj, counter, ScaleFactor::TIMES_2, value_offset));
1479 __ negl(counter);
1480 __ leal(counter, Address(string_length, counter, ScaleFactor::TIMES_1, 0));
1486 __ repne_scasw();
1489 __ j(kNotEqual, ¬_found_label);
1492 __ subl(string_length, counter);
1493 __ leal(out, Address(string_length, -1));
1496 __ jmp(&done);
1499 __ Bind(¬_found_label);
1500 __ movl(out, Immediate(-1));
1503 __ Bind(&done);
1505 __ Bind(slow_path->GetExitLabel());
1543 __ testl(byte_array, byte_array);
1546 __ j(kEqual, slow_path->GetEntryLabel());
1548 __ fs()->call(Address::Absolute(QUICK_ENTRYPOINT_OFFSET(kX86WordSize, pAllocStringFromBytes)));
1551 __ Bind(slow_path->GetExitLabel());
1574 __ fs()->call(Address::Absolute(QUICK_ENTRYPOINT_OFFSET(kX86WordSize, pAllocStringFromChars)));
1593 __ testl(string_to_copy, string_to_copy);
1596 __ j(kEqual, slow_path->GetEntryLabel());
1598 __ fs()->call(Address::Absolute(QUICK_ENTRYPOINT_OFFSET(kX86WordSize, pAllocStringFromString)));
1601 __ Bind(slow_path->GetExitLabel());
1646 __ leal(EDI, Address(dst, dstBegin, ScaleFactor::TIMES_2, data_offset));
1652 __ leal(ESI, Address(obj, srcBegin_value * char_size + value_offset));
1654 __ leal(ESI, Address(obj, srcBegin.AsRegister<Register>(),
1660 __ pushl(ECX);
1662 __ cfi().AdjustCFAOffset(stack_adjust);
1666 __ subl(ECX, Immediate(srcBegin_value));
1670 __ subl(ECX, srcBegin.AsRegister<Register>());
1674 __ rep_movsw();
1677 __ popl(ECX);
1678 __ cfi().AdjustCFAOffset(-stack_adjust);
1688 __ movsxb(out_loc.AsRegister<Register>(), Address(address, 0));
1691 __ movsxw(out_loc.AsRegister<Register>(), Address(address, 0));
1694 __ movl(out_loc.AsRegister<Register>(), Address(address, 0));
1697 __ movl(out_loc.AsRegisterPairLow<Register>(), Address(address, 0));
1698 __ movl(out_loc.AsRegisterPairHigh<Register>(), Address(address, 4));
1760 __ movb(Address(address, 0),
1763 __ movb(Address(address, 0), value_loc.AsRegister<ByteRegister>());
1768 __ movw(Address(address, 0),
1771 __ movw(Address(address, 0), value_loc.AsRegister<Register>());
1776 __ movl(Address(address, 0),
1779 __ movl(Address(address, 0), value_loc.AsRegister<Register>());
1785 __ movl(Address(address, 0), Immediate(Low32Bits(value)));
1786 __ movl(Address(address, 4), Immediate(High32Bits(value)));
1788 __ movl(Address(address, 0), value_loc.AsRegisterPairLow<Register>());
1789 __ movl(Address(address, 4), value_loc.AsRegisterPairHigh<Register>());
1857 __ movl(output, Address(base, offset, ScaleFactor::TIMES_1, 0));
1869 __ movl(output, Address(base, offset, ScaleFactor::TIMES_1, 0));
1874 __ movl(output, Address(base, offset, ScaleFactor::TIMES_1, 0));
1875 __ MaybeUnpoisonHeapReference(output);
1886 __ movsd(temp, Address(base, offset, ScaleFactor::TIMES_1, 0));
1887 __ movd(output_lo, temp);
1888 __ psrlq(temp, Immediate(32));
1889 __ movd(output_hi, temp);
1891 __ movl(output_lo, Address(base, offset, ScaleFactor::TIMES_1, 0));
1892 __ movl(output_hi, Address(base, offset, ScaleFactor::TIMES_1, 4));
2052 __ movd(temp1, value_lo);
2053 __ movd(temp2, value_hi);
2054 __ punpckldq(temp1, temp2);
2055 __ movsd(Address(base, offset, ScaleFactor::TIMES_1, 0), temp1);
2057 __ movl(Address(base, offset, ScaleFactor::TIMES_1, 0), value_lo);
2058 __ movl(Address(base, offset, ScaleFactor::TIMES_1, 4), value_hi);
2062 __ movl(temp, value_loc.AsRegister<Register>());
2063 __ PoisonHeapReference(temp);
2064 __ movl(Address(base, offset, ScaleFactor::TIMES_1, 0), temp);
2066 __ movl(Address(base, offset, ScaleFactor::TIMES_1, 0), value_loc.AsRegister<Register>());
2194 __ movl(value, base);
2208 __ PoisonHeapReference(expected);
2209 __ PoisonHeapReference(value);
2219 __ LockCmpxchgl(Address(base, offset, TIMES_1, 0), value);
2225 __ setb(kZero, out.AsRegister<Register>());
2226 __ movzxb(out.AsRegister<Register>(), out.AsRegister<ByteRegister>());
2238 __ UnpoisonHeapReference(value);
2248 __ LockCmpxchgl(Address(base, offset, TIMES_1, 0),
2257 __ LockCmpxchg8b(Address(base, offset, TIMES_1, 0));
2266 __ setb(kZero, out.AsRegister<Register>());
2267 __ movzxb(out.AsRegister<Register>(), out.AsRegister<ByteRegister>());
2296 __ movl(temp, reg);
2297 __ shrl(reg, imm_shift);
2298 __ andl(temp, imm_mask);
2299 __ andl(reg, imm_mask);
2300 __ shll(temp, imm_shift);
2301 __ orl(reg, temp);
2320 __ bswapl(reg);
2346 __ movl(temp, reg_low);
2347 __ movl(reg_low, reg_high);
2348 __ movl(reg_high, temp);
2351 __ bswapl(reg_low);
2357 __ bswapl(reg_high);
2400 __ popcntl(out, src.AsRegister<Register>());
2403 __ popcntl(out, Address(ESP, src.GetStackIndex()));
2409 __ popcntl(temp, src.AsRegisterPairLow<Register>());
2410 __ popcntl(out, src.AsRegisterPairHigh<Register>());
2413 __ popcntl(temp, Address(ESP, src.GetStackIndex()));
2414 __ popcntl(out, Address(ESP, src.GetHighStackIndex(kX86WordSize)));
2416 __ addl(out, temp);
2470 __ bsrl(out, src.AsRegister<Register>());
2473 __ bsrl(out, Address(ESP, src.GetStackIndex()));
2478 __ j(kEqual, &all_zeroes);
2481 __ xorl(out, Immediate(31));
2482 __ jmp(&done);
2485 __ Bind(&all_zeroes);
2486 __ movl(out, Immediate(32));
2488 __ Bind(&done);
2499 __ testl(src_hi, src_hi);
2500 __ j(kEqual, &handle_low);
2503 __ bsrl(out, src_hi);
2506 __ xorl(out, Immediate(31));
2507 __ jmp(&done);
2510 __ Bind(&handle_low);
2511 __ bsrl(out, src_lo);
2512 __ j(kEqual, &all_zeroes);
2515 __ xorl(out, Immediate(63));
2516 __ jmp(&done);
2519 __ Bind(&all_zeroes);
2520 __ movl(out, Immediate(64));
2522 __ Bind(&done);
2575 __ bsfl(out, src.AsRegister<Register>());
2578 __ bsfl(out, Address(ESP, src.GetStackIndex()));
2583 __ j(kNotEqual, &done);
2586 __ movl(out, Immediate(32));
2588 __ Bind(&done);
2599 __ bsfl(out, src_lo);
2600 __ j(kNotEqual, &done);
2603 __ bsfl(out, src_hi);
2604 __ j(kEqual, &all_zeroes);
2607 __ addl(out, Immediate(32));
2608 __ jmp(&done);
2611 __ Bind(&all_zeroes);
2612 __ movl(out, Immediate(64));
2614 __ Bind(&done);
2652 #undef __