Lines Matching refs:__
54 #define __ down_cast<X86_64Assembler*>(codegen->GetAssembler())->
63 __ Bind(GetEntryLabel());
89 __ Bind(GetEntryLabel());
115 __ Bind(GetEntryLabel());
118 __ negl(cpu_reg_);
120 __ xorl(cpu_reg_, cpu_reg_);
126 __ negq(cpu_reg_);
128 __ xorl(cpu_reg_, cpu_reg_);
131 __ jmp(GetExitLabel());
150 __ Bind(GetEntryLabel());
159 __ jmp(GetReturnLabel());
161 __ jmp(x86_64_codegen->GetLabelOf(successor_));
191 __ Bind(GetEntryLabel());
234 __ Bind(GetEntryLabel());
239 __ movl(CpuRegister(calling_convention.GetRegisterAt(0)), Immediate(cls_->GetTypeIndex()));
260 __ jmp(GetExitLabel());
291 __ Bind(GetEntryLabel());
296 __ movl(CpuRegister(calling_convention.GetRegisterAt(0)), Immediate(string_index));
304 __ jmp(GetExitLabel());
327 __ Bind(GetEntryLabel());
366 __ jmp(GetExitLabel());
387 __ Bind(GetEntryLabel());
408 __ Bind(GetEntryLabel());
437 __ jmp(GetExitLabel());
471 __ Bind(GetEntryLabel());
485 __ jmp(GetExitLabel());
515 // __ movl(out, Address(out, offset));
536 __ Bind(GetEntryLabel());
573 __ movl(CpuRegister(free_reg), CpuRegister(index_reg));
586 __ shll(CpuRegister(index_reg), Immediate(TIMES_4));
590 __ AddImmediate(CpuRegister(index_reg), Immediate(offset_));
622 __ movl(CpuRegister(calling_convention.GetRegisterAt(2)), Immediate(offset_));
633 __ jmp(GetExitLabel());
686 __ Bind(GetEntryLabel());
700 __ jmp(GetExitLabel());
712 #undef __
713 #define __ down_cast<X86_64Assembler*>(GetAssembler())->
773 __ gs()->movq(temp.AsRegister<CpuRegister>(),
780 __ movq(temp.AsRegister<CpuRegister>(), Immediate(invoke->GetMethodAddress()));
783 __ movl(temp.AsRegister<CpuRegister>(), Immediate(0)); // Placeholder.
785 __ Bind(&method_patches_.back().label); // Bind the label at the end of the "movl" insn.
788 __ movq(temp.AsRegister<CpuRegister>(),
792 __ Bind(NewPcRelativeDexCacheArrayPatch(*invoke->GetTargetMethod().dex_file, offset));
805 __ movq(reg, Address(CpuRegister(RSP), kCurrentMethodStackOffset));
808 __ movq(reg,
814 __ movq(reg, Address(reg, CodeGenerator::GetCachePointerOffset(index_in_cache)));
821 __ call(&frame_entry_label_);
826 __ call(label); // Bind to the patch label, override at link time.
827 __ Bind(label); // Bind the label at the end of the "call" insn.
837 __ call(Address(callee_method.AsRegister<CpuRegister>(),
860 __ movl(temp, Address(CpuRegister(receiver), class_offset));
869 __ MaybeUnpoisonHeapReference(temp);
871 __ movq(temp, Address(temp, method_offset));
873 __ call(Address(temp, ArtMethod::EntryPointFromQuickCompiledCodeOffset(
880 __ Bind(&simple_patches_.back());
886 __ Bind(&string_patches_.back().label);
950 __ movq(Address(CpuRegister(RSP), stack_index), CpuRegister(reg_id));
955 __ movq(CpuRegister(reg_id), Address(CpuRegister(RSP), stack_index));
960 __ movsd(Address(CpuRegister(RSP), stack_index), XmmRegister(reg_id));
965 __ movsd(XmmRegister(reg_id), Address(CpuRegister(RSP), stack_index));
984 __ gs()->call(Address::Absolute(entry_point_offset, /* no_rip */ true));
1045 __ cfi().SetCurrentCFAOffset(kX86_64WordSize); // return address
1046 __ Bind(&frame_entry_label_);
1052 __ testq(CpuRegister(RAX), Address(
1064 __ pushq(CpuRegister(reg));
1065 __ cfi().AdjustCFAOffset(kX86_64WordSize);
1066 __ cfi().RelOffset(DWARFReg(reg), 0);
1071 __ subq(CpuRegister(RSP), Immediate(adjust));
1072 __ cfi().AdjustCFAOffset(adjust);
1079 __ movsd(Address(CpuRegister(RSP), offset), XmmRegister(kFpuCalleeSaves[i]));
1080 __ cfi().RelOffset(DWARFReg(kFpuCalleeSaves[i]), offset);
1084 __ movq(Address(CpuRegister(RSP), kCurrentMethodStackOffset),
1089 __ cfi().RememberState();
1096 __ movsd(XmmRegister(kFpuCalleeSaves[i]), Address(CpuRegister(RSP), offset));
1097 __ cfi().Restore(DWARFReg(kFpuCalleeSaves[i]));
1102 __ addq(CpuRegister(RSP), Immediate(adjust));
1103 __ cfi().AdjustCFAOffset(-adjust);
1108 __ popq(CpuRegister(reg));
1109 __ cfi().AdjustCFAOffset(-static_cast<int>(kX86_64WordSize));
1110 __ cfi().Restore(DWARFReg(reg));
1114 __ ret();
1115 __ cfi().RestoreState();
1116 __ cfi().DefCFAOffset(GetFrameSize());
1120 __ Bind(GetLabelOf(block));
1130 __ movq(dest, source.AsRegister<CpuRegister>());
1132 __ movd(dest, source.AsFpuRegister<XmmRegister>());
1134 __ movl(dest, Address(CpuRegister(RSP), source.GetStackIndex()));
1144 __ movq(dest, Address(CpuRegister(RSP), source.GetStackIndex()));
1149 __ movd(dest, source.AsRegister<CpuRegister>());
1151 __ movaps(dest, source.AsFpuRegister<XmmRegister>());
1161 __ movss(dest, Address(CpuRegister(RSP), source.GetStackIndex()));
1164 __ movsd(dest, Address(CpuRegister(RSP), source.GetStackIndex()));
1168 __ movl(Address(CpuRegister(RSP), destination.GetStackIndex()),
1171 __ movss(Address(CpuRegister(RSP), destination.GetStackIndex()),
1176 __ movl(Address(CpuRegister(RSP), destination.GetStackIndex()), Immediate(value));
1179 __ movl(CpuRegister(TMP), Address(CpuRegister(RSP), source.GetStackIndex()));
1180 __ movl(Address(CpuRegister(RSP), destination.GetStackIndex()), CpuRegister(TMP));
1185 __ movq(Address(CpuRegister(RSP), destination.GetStackIndex()),
1188 __ movsd(Address(CpuRegister(RSP), destination.GetStackIndex()),
1202 __ movq(CpuRegister(TMP), Address(CpuRegister(RSP), source.GetStackIndex()));
1203 __ movq(Address(CpuRegister(RSP), destination.GetStackIndex()), CpuRegister(TMP));
1242 __ jmp(codegen_->GetLabelOf(successor));
1277 __ j(kUnordered, true_label);
1279 __ j(kUnordered, false_label);
1281 __ j(X86_64FPCondition(cond->GetCondition()), true_label);
1301 __ testl(left_reg, left_reg);
1303 __ cmpl(left_reg, Immediate(value));
1306 __ cmpl(left_reg, Address(CpuRegister(RSP), right.GetStackIndex()));
1308 __ cmpl(left_reg, right.AsRegister<CpuRegister>());
1318 __ cmpq(left_reg, Address(CpuRegister(RSP), right.GetStackIndex()));
1320 __ cmpq(left_reg, right.AsRegister<CpuRegister>());
1326 __ ucomiss(left.AsFpuRegister<XmmRegister>(), right.AsFpuRegister<XmmRegister>());
1328 __ ucomiss(left.AsFpuRegister<XmmRegister>(),
1333 __ ucomiss(left.AsFpuRegister<XmmRegister>(),
1340 __ ucomisd(left.AsFpuRegister<XmmRegister>(), right.AsFpuRegister<XmmRegister>());
1342 __ ucomisd(left.AsFpuRegister<XmmRegister>(),
1347 __ ucomisd(left.AsFpuRegister<XmmRegister>(),
1374 __ j(X86_64IntegerCondition(condition->GetCondition()), true_target);
1390 __ jmp(false_target);
1394 __ Bind(&fallthrough_target);
1421 __ jmp(true_target);
1426 __ jmp(false_target);
1443 __ j(X86_64IntegerCondition(cond->AsCondition()->GetOppositeCondition()), false_target);
1445 __ j(X86_64IntegerCondition(cond->AsCondition()->GetCondition()), true_target);
1451 __ testl(lhs.AsRegister<CpuRegister>(), lhs.AsRegister<CpuRegister>());
1453 __ cmpl(Address(CpuRegister(RSP), lhs.GetStackIndex()), Immediate(0));
1456 __ j(kEqual, false_target);
1458 __ j(kNotEqual, true_target);
1477 __ cmpl(lhs.AsRegister<CpuRegister>(), rhs.AsRegister<CpuRegister>());
1482 __ cmpl(lhs.AsRegister<CpuRegister>(),
1486 __ j(X86_64IntegerCondition(condition->GetOppositeCondition()), false_target);
1488 __ j(X86_64IntegerCondition(condition->GetCondition()), true_target);
1495 __ jmp(false_target);
1596 __ testl(cond_reg, cond_reg);
1605 __ testl(cond_reg, cond_reg);
1612 __ cmov(cond, value_false, value_true_loc.AsRegister<CpuRegister>(), is_64_bit);
1614 __ cmov(cond,
1625 __ Bind(&false_target);
1638 __ nop();
1681 __ xorl(reg, reg);
1684 __ cmpl(lhs.AsRegister<CpuRegister>(), rhs.AsRegister<CpuRegister>());
1689 __ cmpl(lhs.AsRegister<CpuRegister>(), Address(CpuRegister(RSP), rhs.GetStackIndex()));
1691 __ setcc(X86_64IntegerCondition(cond->GetCondition()), reg);
1695 __ xorl(reg, reg);
1698 __ cmpq(lhs.AsRegister<CpuRegister>(), rhs.AsRegister<CpuRegister>());
1703 __ cmpq(lhs.AsRegister<CpuRegister>(), Address(CpuRegister(RSP), rhs.GetStackIndex()));
1705 __ setcc(X86_64IntegerCondition(cond->GetCondition()), reg);
1711 __ ucomiss(lhs_reg, codegen_->LiteralFloatAddress(value));
1713 __ ucomiss(lhs_reg, Address(CpuRegister(RSP), rhs.GetStackIndex()));
1715 __ ucomiss(lhs_reg, rhs.AsFpuRegister<XmmRegister>());
1724 __ ucomisd(lhs_reg, codegen_->LiteralDoubleAddress(value));
1726 __ ucomisd(lhs_reg, Address(CpuRegister(RSP), rhs.GetStackIndex()));
1728 __ ucomisd(lhs_reg, rhs.AsFpuRegister<XmmRegister>());
1739 __ Bind(&false_label);
1740 __ xorl(reg, reg);
1741 __ jmp(&done_label);
1744 __ Bind(&true_label);
1745 __ movl(reg, Immediate(1));
1746 __ Bind(&done_label);
1877 __ cmpl(left_reg, Address(CpuRegister(RSP), right.GetStackIndex()));
1879 __ cmpl(left_reg, right.AsRegister<CpuRegister>());
1889 __ cmpq(left_reg, Address(CpuRegister(RSP), right.GetStackIndex()));
1891 __ cmpq(left_reg, right.AsRegister<CpuRegister>());
1899 __ ucomiss(left_reg, codegen_->LiteralFloatAddress(value));
1901 __ ucomiss(left_reg, Address(CpuRegister(RSP), right.GetStackIndex()));
1903 __ ucomiss(left_reg, right.AsFpuRegister<XmmRegister>());
1905 __ j(kUnordered, compare->IsGtBias() ? &greater : &less);
1913 __ ucomisd(left_reg, codegen_->LiteralDoubleAddress(value));
1915 __ ucomisd(left_reg, Address(CpuRegister(RSP), right.GetStackIndex()));
1917 __ ucomisd(left_reg, right.AsFpuRegister<XmmRegister>());
1919 __ j(kUnordered, compare->IsGtBias() ? &greater : &less);
1927 __ movl(out, Immediate(0));
1928 __ j(kEqual, &done);
1929 __ j(less_cond, &less);
1931 __ Bind(&greater);
1932 __ movl(out, Immediate(1));
1933 __ jmp(&done);
1935 __ Bind(&less);
1936 __ movl(out, Immediate(-1));
1938 __ Bind(&done);
2232 __ movl(temp, Address(CpuRegister(RSP), receiver.GetStackIndex()));
2234 __ movl(temp, Address(temp, class_offset));
2237 __ movl(temp, Address(receiver.AsRegister<CpuRegister>(), class_offset));
2247 __ MaybeUnpoisonHeapReference(temp);
2249 __ movq(temp,
2255 __ movq(temp, Address(temp, method_offset));
2257 __ call(Address(temp,
2294 __ negl(out.AsRegister<CpuRegister>());
2300 __ negq(out.AsRegister<CpuRegister>());
2309 __ movss(mask, codegen_->LiteralInt32Address(0x80000000));
2310 __ xorps(out.AsFpuRegister<XmmRegister>(), mask);
2320 __ movsd(mask, codegen_->LiteralInt64Address(INT64_C(0x8000000000000000)));
2321 __ xorpd(out.AsFpuRegister<XmmRegister>(), mask);
2547 __ movsxb(out.AsRegister<CpuRegister>(), in.AsRegister<CpuRegister>());
2549 __ movsxb(out.AsRegister<CpuRegister>(),
2552 __ movl(out.AsRegister<CpuRegister>(),
2574 __ movsxw(out.AsRegister<CpuRegister>(), in.AsRegister<CpuRegister>());
2576 __ movsxw(out.AsRegister<CpuRegister>(),
2579 __ movl(out.AsRegister<CpuRegister>(),
2595 __ movl(out.AsRegister<CpuRegister>(), in.AsRegister<CpuRegister>());
2597 __ movl(out.AsRegister<CpuRegister>(),
2603 __ movl(out.AsRegister<CpuRegister>(), Immediate(static_cast<int32_t>(value)));
2613 __ movl(output, Immediate(kPrimIntMax));
2615 __ comiss(input, codegen_->LiteralFloatAddress(kPrimIntMax));
2616 __ j(kAboveEqual, &done);
2618 __ j(kUnordered, &nan);
2620 __ cvttss2si(output, input, false);
2621 __ jmp(&done);
2622 __ Bind(&nan);
2624 __ xorl(output, output);
2625 __ Bind(&done);
2635 __ movl(output, Immediate(kPrimIntMax));
2637 __ comisd(input, codegen_->LiteralDoubleAddress(kPrimIntMax));
2638 __ j(kAboveEqual, &done);
2640 __ j(kUnordered, &nan);
2642 __ cvttsd2si(output, input);
2643 __ jmp(&done);
2644 __ Bind(&nan);
2646 __ xorl(output, output);
2647 __ Bind(&done);
2668 __ movsxd(out.AsRegister<CpuRegister>(), in.AsRegister<CpuRegister>());
2679 __ comiss(input, codegen_->LiteralFloatAddress(kPrimLongMax));
2680 __ j(kAboveEqual, &done);
2682 __ j(kUnordered, &nan);
2684 __ cvttss2si(output, input, true);
2685 __ jmp(&done);
2686 __ Bind(&nan);
2688 __ xorl(output, output);
2689 __ Bind(&done);
2701 __ comisd(input, codegen_->LiteralDoubleAddress(kPrimLongMax));
2702 __ j(kAboveEqual, &done);
2704 __ j(kUnordered, &nan);
2706 __ cvttsd2si(output, input, true);
2707 __ jmp(&done);
2708 __ Bind(&nan);
2710 __ xorl(output, output);
2711 __ Bind(&done);
2732 __ movzxw(out.AsRegister<CpuRegister>(), in.AsRegister<CpuRegister>());
2734 __ movzxw(out.AsRegister<CpuRegister>(),
2737 __ movl(out.AsRegister<CpuRegister>(),
2758 __ cvtsi2ss(out.AsFpuRegister<XmmRegister>(), in.AsRegister<CpuRegister>(), false);
2764 __ cvtsi2ss(out.AsFpuRegister<XmmRegister>(),
2772 __ cvtsi2ss(out.AsFpuRegister<XmmRegister>(), in.AsRegister<CpuRegister>(), true);
2778 __ cvtsi2ss(out.AsFpuRegister<XmmRegister>(),
2786 __ cvtsd2ss(out.AsFpuRegister<XmmRegister>(), in.AsFpuRegister<XmmRegister>());
2792 __ cvtsd2ss(out.AsFpuRegister<XmmRegister>(),
2813 __ cvtsi2sd(out.AsFpuRegister<XmmRegister>(), in.AsRegister<CpuRegister>(), false);
2819 __ cvtsi2sd(out.AsFpuRegister<XmmRegister>(),
2827 __ cvtsi2sd(out.AsFpuRegister<XmmRegister>(), in.AsRegister<CpuRegister>(), true);
2833 __ cvtsi2sd(out.AsFpuRegister<XmmRegister>(),
2841 __ cvtss2sd(out.AsFpuRegister<XmmRegister>(), in.AsFpuRegister<XmmRegister>());
2847 __ cvtss2sd(out.AsFpuRegister<XmmRegister>(),
2906 __ addl(out.AsRegister<CpuRegister>(), second.AsRegister<CpuRegister>());
2908 __ addl(out.AsRegister<CpuRegister>(), first.AsRegister<CpuRegister>());
2910 __ leal(out.AsRegister<CpuRegister>(), Address(
2915 __ addl(out.AsRegister<CpuRegister>(),
2918 __ leal(out.AsRegister<CpuRegister>(), Address(
2923 __ addl(first.AsRegister<CpuRegister>(), Address(CpuRegister(RSP), second.GetStackIndex()));
2931 __ addq(out.AsRegister<CpuRegister>(), second.AsRegister<CpuRegister>());
2933 __ addq(out.AsRegister<CpuRegister>(), first.AsRegister<CpuRegister>());
2935 __ leaq(out.AsRegister<CpuRegister>(), Address(
2944 __ addq(out.AsRegister<CpuRegister>(), Immediate(int32_value));
2946 __ leaq(out.AsRegister<CpuRegister>(), Address(
2955 __ addss(first.AsFpuRegister<XmmRegister>(), second.AsFpuRegister<XmmRegister>());
2957 __ addss(first.AsFpuRegister<XmmRegister>(),
2962 __ addss(first.AsFpuRegister<XmmRegister>(),
2970 __ addsd(first.AsFpuRegister<XmmRegister>(), second.AsFpuRegister<XmmRegister>());
2972 __ addsd(first.AsFpuRegister<XmmRegister>(),
2977 __ addsd(first.AsFpuRegister<XmmRegister>(),
3024 __ subl(first.AsRegister<CpuRegister>(), second.AsRegister<CpuRegister>());
3027 __ subl(first.AsRegister<CpuRegister>(), imm);
3029 __ subl(first.AsRegister<CpuRegister>(), Address(CpuRegister(RSP), second.GetStackIndex()));
3037 __ subq(first.AsRegister<CpuRegister>(), Immediate(static_cast<int32_t>(value)));
3039 __ subq(first.AsRegister<CpuRegister>(), second.AsRegister<CpuRegister>());
3046 __ subss(first.AsFpuRegister<XmmRegister>(), second.AsFpuRegister<XmmRegister>());
3048 __ subss(first.AsFpuRegister<XmmRegister>(),
3053 __ subss(first.AsFpuRegister<XmmRegister>(),
3061 __ subsd(first.AsFpuRegister<XmmRegister>(), second.AsFpuRegister<XmmRegister>());
3063 __ subsd(first.AsFpuRegister<XmmRegister>(),
3068 __ subsd(first.AsFpuRegister<XmmRegister>(),
3130 __ imull(out.AsRegister<CpuRegister>(), first.AsRegister<CpuRegister>(), imm);
3133 __ imull(first.AsRegister<CpuRegister>(), second.AsRegister<CpuRegister>());
3137 __ imull(first.AsRegister<CpuRegister>(),
3147 __ imulq(out.AsRegister<CpuRegister>(), first.AsRegister<CpuRegister>(),
3152 __ imulq(first.AsRegister<CpuRegister>(), codegen_->LiteralInt64Address(value));
3156 __ imulq(first.AsRegister<CpuRegister>(), second.AsRegister<CpuRegister>());
3160 __ imulq(first.AsRegister<CpuRegister>(),
3169 __ mulss(first.AsFpuRegister<XmmRegister>(), second.AsFpuRegister<XmmRegister>());
3171 __ mulss(first.AsFpuRegister<XmmRegister>(),
3176 __ mulss(first.AsFpuRegister<XmmRegister>(),
3185 __ mulsd(first.AsFpuRegister<XmmRegister>(), second.AsFpuRegister<XmmRegister>());
3187 __ mulsd(first.AsFpuRegister<XmmRegister>(),
3192 __ mulsd(first.AsFpuRegister<XmmRegister>(),
3207 __ flds(Address(CpuRegister(RSP), source.GetStackIndex() + stack_adjustment));
3210 __ fldl(Address(CpuRegister(RSP), source.GetStackIndex() + stack_adjustment));
3216 __ flds(Address(CpuRegister(RSP), temp_offset));
3220 __ fldl(Address(CpuRegister(RSP), temp_offset));
3236 __ subq(CpuRegister(RSP), Immediate(2 * elem_size));
3244 __ Bind(&retry);
3245 __ fprem();
3248 __ fstsw();
3252 __ andl(CpuRegister(RAX), Immediate(kC2ConditionMask));
3253 __ j(kNotEqual, &retry);
3258 __ fsts(Address(CpuRegister(RSP), 0));
3260 __ fstl(Address(CpuRegister(RSP), 0));
3264 __ fucompp();
3269 __ movss(out.AsFpuRegister<XmmRegister>(), Address(CpuRegister(RSP), 0));
3271 __ movsd(out.AsFpuRegister<XmmRegister>(), Address(CpuRegister(RSP), 0));
3275 __ addq(CpuRegister(RSP), Immediate(2 * elem_size));
3294 __ xorl(output_register, output_register);
3296 __ movl(output_register, input_register);
3298 __ negl(output_register);
3306 __ xorl(output_register, output_register);
3308 __ movq(output_register, input_register);
3310 __ negq(output_register);
3335 __ leal(tmp, Address(numerator, abs_imm - 1));
3336 __ testl(numerator, numerator);
3337 __ cmov(kGreaterEqual, tmp, numerator);
3339 __ sarl(tmp, Immediate(shift));
3342 __ negl(tmp);
3345 __ movl(output_register, tmp);
3351 __ addq(rdx, numerator);
3352 __ testq(numerator, numerator);
3353 __ cmov(kGreaterEqual, rdx, numerator);
3355 __ sarq(rdx, Immediate(shift));
3358 __ negq(rdx);
3361 __ movq(output_register, rdx);
3395 __ movl(numerator, eax);
3399 __ testl(eax, eax);
3400 __ j(kNotEqual, &no_div);
3402 __ xorl(out, out);
3403 __ jmp(&end);
3405 __ Bind(&no_div);
3407 __ movl(eax, Immediate(magic));
3408 __ imull(numerator);
3411 __ addl(edx, numerator);
3413 __ subl(edx, numerator);
3417 __ sarl(edx, Immediate(shift));
3420 __ movl(eax, edx);
3421 __ shrl(edx, Immediate(31));
3422 __ addl(edx, eax);
3425 __ movl(eax, numerator);
3426 __ imull(edx, Immediate(imm));
3427 __ subl(eax, edx);
3428 __ movl(edx, eax);
3430 __ movl(eax, edx);
3432 __ Bind(&end);
3444 __ movq(numerator, rax);
3450 __ imulq(numerator);
3454 __ addq(rdx, numerator);
3457 __ subq(rdx, numerator);
3462 __ sarq(rdx, Immediate(shift));
3466 __ movq(rax, rdx);
3467 __ shrq(rdx, Immediate(63));
3468 __ addq(rdx, rax);
3471 __ movq(rax, numerator);
3474 __ imulq(rdx, Immediate(static_cast<int32_t>(imm)));
3476 __ imulq(rdx, codegen_->LiteralInt64Address(imm));
3479 __ subq(rax, rdx);
3480 __ movq(rdx, rax);
3482 __ movq(rax, rdx);
3525 __ cmpl(second_reg, Immediate(-1));
3526 __ j(kEqual, slow_path->GetEntryLabel());
3528 __ cdq();
3530 __ idivl(second_reg);
3532 __ cmpq(second_reg, Immediate(-1));
3533 __ j(kEqual, slow_path->GetEntryLabel());
3535 __ cqo();
3537 __ idivq(second_reg);
3539 __ Bind(slow_path->GetExitLabel());
3592 __ divss(first.AsFpuRegister<XmmRegister>(), second.AsFpuRegister<XmmRegister>());
3594 __ divss(first.AsFpuRegister<XmmRegister>(),
3599 __ divss(first.AsFpuRegister<XmmRegister>(),
3607 __ divsd(first.AsFpuRegister<XmmRegister>(), second.AsFpuRegister<XmmRegister>());
3609 __ divsd(first.AsFpuRegister<XmmRegister>(),
3614 __ divsd(first.AsFpuRegister<XmmRegister>(),
3704 __ testl(value.AsRegister<CpuRegister>(), value.AsRegister<CpuRegister>());
3705 __ j(kEqual, slow_path->GetEntryLabel());
3707 __ cmpl(Address(CpuRegister(RSP), value.GetStackIndex()), Immediate(0));
3708 __ j(kEqual, slow_path->GetEntryLabel());
3712 __ jmp(slow_path->GetEntryLabel());
3719 __ testq(value.AsRegister<CpuRegister>(), value.AsRegister<CpuRegister>());
3720 __ j(kEqual, slow_path->GetEntryLabel());
3722 __ cmpq(Address(CpuRegister(RSP), value.GetStackIndex()), Immediate(0));
3723 __ j(kEqual, slow_path->GetEntryLabel());
3727 __ jmp(slow_path->GetEntryLabel());
3769 __ shll(first_reg, second_reg);
3771 __ sarl(first_reg, second_reg);
3773 __ shrl(first_reg, second_reg);
3778 __ shll(first_reg, imm);
3780 __ sarl(first_reg, imm);
3782 __ shrl(first_reg, imm);
3791 __ shlq(first_reg, second_reg);
3793 __ sarq(first_reg, second_reg);
3795 __ shrq(first_reg, second_reg);
3800 __ shlq(first_reg, imm);
3802 __ sarq(first_reg, imm);
3804 __ shrq(first_reg, imm);
3843 __ rorl(first_reg, second_reg);
3846 __ rorl(first_reg, imm);
3852 __ rorq(first_reg, second_reg);
3855 __ rorq(first_reg, imm);
3908 __ gs()->movq(temp, Address::Absolute(QUICK_ENTRY_POINT(pNewEmptyString), /* no_rip */ true));
3909 __ call(Address(temp, code_offset.SizeValue()));
3986 __ movq(locations->Out().AsRegister<CpuRegister>(),
3991 __ movq(locations->Out().AsRegister<CpuRegister>(),
3994 __ movq(locations->Out().AsRegister<CpuRegister>(),
4013 __ notl(out.AsRegister<CpuRegister>());
4017 __ notq(out.AsRegister<CpuRegister>());
4037 __ xorl(out.AsRegister<CpuRegister>(), Immediate(1));
4117 __ movzxb(out.AsRegister<CpuRegister>(), Address(base, offset));
4122 __ movsxb(out.AsRegister<CpuRegister>(), Address(base, offset));
4127 __ movsxw(out.AsRegister<CpuRegister>(), Address(base, offset));
4132 __ movzxw(out.AsRegister<CpuRegister>(), Address(base, offset));
4137 __ movl(out.AsRegister<CpuRegister>(), Address(base, offset));
4153 __ movl(out.AsRegister<CpuRegister>(), Address(base, offset));
4167 __ movq(out.AsRegister<CpuRegister>(), Address(base, offset));
4172 __ movss(out.AsFpuRegister<XmmRegister>(), Address(base, offset));
4177 __ movsd(out.AsFpuRegister<XmmRegister>(), Address(base, offset));
4263 __ movb(Address(base, offset), Immediate(v));
4265 __ movb(Address(base, offset), value.AsRegister<CpuRegister>());
4274 __ movw(Address(base, offset), Immediate(v));
4276 __ movw(Address(base, offset), value.AsRegister<CpuRegister>());
4289 __ movl(Address(base, offset), Immediate(v));
4293 __ movl(temp, value.AsRegister<CpuRegister>());
4294 __ PoisonHeapReference(temp);
4295 __ movl(Address(base, offset), temp);
4297 __ movl(Address(base, offset), value.AsRegister<CpuRegister>());
4312 __ movq(Address(base, offset), value.AsRegister<CpuRegister>());
4321 __ movl(Address(base, offset), Immediate(v));
4323 __ movss(Address(base, offset), value.AsFpuRegister<XmmRegister>());
4338 __ movsd(Address(base, offset), value.AsFpuRegister<XmmRegister>());
4484 __ testl(CpuRegister(RAX), Address(obj.AsRegister<CpuRegister>(), 0));
4496 __ testl(obj.AsRegister<CpuRegister>(), obj.AsRegister<CpuRegister>());
4498 __ cmpl(Address(CpuRegister(RSP), obj.GetStackIndex()), Immediate(0));
4502 __ jmp(slow_path->GetEntryLabel());
4505 __ j(kEqual, slow_path->GetEntryLabel());
4552 __ movzxb(out, Address(obj,
4555 __ movzxb(out, Address(obj, index.AsRegister<CpuRegister>(), TIMES_1, data_offset));
4564 __ movsxb(out, Address(obj,
4567 __ movsxb(out, Address(obj, index.AsRegister<CpuRegister>(), TIMES_1, data_offset));
4576 __ movsxw(out, Address(obj,
4579 __ movsxw(out, Address(obj, index.AsRegister<CpuRegister>(), TIMES_2, data_offset));
4588 __ movzxw(out, Address(obj,
4591 __ movzxw(out, Address(obj, index.AsRegister<CpuRegister>(), TIMES_2, data_offset));
4600 __ movl(out, Address(obj,
4603 __ movl(out, Address(obj, index.AsRegister<CpuRegister>(), TIMES_4, data_offset));
4626 __ movl(out, Address(obj, offset));
4633 __ movl(out, Address(obj, index.AsRegister<CpuRegister>(), TIMES_4, data_offset));
4649 __ movq(out, Address(obj,
4652 __ movq(out, Address(obj, index.AsRegister<CpuRegister>(), TIMES_8, data_offset));
4661 __ movss(out, Address(obj,
4664 __ movss(out, Address(obj, index.AsRegister<CpuRegister>(), TIMES_4, data_offset));
4673 __ movsd(out, Address(obj,
4676 __ movsd(out, Address(obj, index.AsRegister<CpuRegister>(), TIMES_8, data_offset));
4749 __ movb(address, value.AsRegister<CpuRegister>());
4751 __ movb(address, Immediate(value.GetConstant()->AsIntConstant()->GetValue()));
4764 __ movw(address, value.AsRegister<CpuRegister>());
4767 __ movw(address, Immediate(value.GetConstant()->AsIntConstant()->GetValue()));
4783 __ movl(address, Immediate(0));
4799 __ testl(register_value, register_value);
4800 __ j(kNotEqual, ¬_null);
4801 __ movl(address, Immediate(0));
4803 __ jmp(&done);
4804 __ Bind(¬_null);
4811 // __ movl(temp2, temp);
4813 // __ movl(temp, Address(temp, component_offset));
4818 // __ movl(temp2, Address(register_value, class_offset));
4822 // __ cmpl(temp, temp2);
4833 __ jmp(slow_path->GetEntryLabel());
4836 __ movl(temp, Address(array, class_offset));
4838 __ MaybeUnpoisonHeapReference(temp);
4841 __ movl(temp, Address(temp, component_offset));
4845 __ cmpl(temp, Address(register_value, class_offset));
4848 __ j(kEqual, &do_put);
4851 __ MaybeUnpoisonHeapReference(temp);
4854 __ movl(temp, Address(temp, super_offset));
4857 __ testl(temp, temp);
4858 __ j(kNotEqual, slow_path->GetEntryLabel());
4859 __ Bind(&do_put);
4861 __ j(kNotEqual, slow_path->GetEntryLabel());
4867 __ movl(temp, register_value);
4868 __ PoisonHeapReference(temp);
4869 __ movl(address, temp);
4871 __ movl(address, register_value);
4880 __ Bind(&done);
4883 __ Bind(slow_path->GetExitLabel());
4895 __ movl(address, value.AsRegister<CpuRegister>());
4899 __ movl(address, Immediate(v));
4911 __ movq(address, value.AsRegister<CpuRegister>());
4930 __ movss(address, value.AsFpuRegister<XmmRegister>());
4935 __ movl(address, Immediate(v));
4947 __ movsd(address, value.AsFpuRegister<XmmRegister>());
4979 __ movl(out, Address(obj, offset));
5009 __ jmp(slow_path->GetEntryLabel());
5019 __ cmpl(index_reg, Immediate(length));
5021 __ j(kAboveEqual, slow_path->GetEntryLabel());
5026 __ cmpl(length, Immediate(value));
5028 __ cmpl(length, index_loc.AsRegister<CpuRegister>());
5031 __ j(kBelowEqual, slow_path->GetEntryLabel());
5042 __ testl(value, value);
5043 __ j(kEqual, &is_null);
5045 __ gs()->movq(card, Address::Absolute(Thread::CardTableOffset<kX86_64WordSize>().Int32Value(),
5047 __ movq(temp, object);
5048 __ shrq(temp, Immediate(gc::accounting::CardTable::kCardShift));
5049 __ movb(Address(temp, card, TIMES_1, 0), card);
5051 __ Bind(&is_null);
5097 __ gs()->cmpw(Address::Absolute(Thread::ThreadFlagsOffset<kX86_64WordSize>().Int32Value(),
5101 __ j(kNotEqual, slow_path->GetEntryLabel());
5102 __ Bind(slow_path->GetReturnLabel());
5104 __ j(kEqual, codegen_->GetLabelOf(successor));
5105 __ jmp(slow_path->GetEntryLabel());
5120 __ movq(destination.AsRegister<CpuRegister>(), source.AsRegister<CpuRegister>());
5122 __ movl(Address(CpuRegister(RSP), destination.GetStackIndex()),
5126 __ movq(Address(CpuRegister(RSP), destination.GetStackIndex()),
5131 __ movl(destination.AsRegister<CpuRegister>(),
5134 __ movss(destination.AsFpuRegister<XmmRegister>(),
5138 __ movl(CpuRegister(TMP), Address(CpuRegister(RSP), source.GetStackIndex()));
5139 __ movl(Address(CpuRegister(RSP), destination.GetStackIndex()), CpuRegister(TMP));
5143 __ movq(destination.AsRegister<CpuRegister>(),
5146 __ movsd(destination.AsFpuRegister<XmmRegister>(),
5150 __ movq(CpuRegister(TMP), Address(CpuRegister(RSP), source.GetStackIndex()));
5151 __ movq(Address(CpuRegister(RSP), destination.GetStackIndex()), CpuRegister(TMP));
5159 __ xorl(destination.AsRegister<CpuRegister>(), destination.AsRegister<CpuRegister>());
5161 __ movl(destination.AsRegister<CpuRegister>(), Immediate(value));
5165 __ movl(Address(CpuRegister(RSP), destination.GetStackIndex()), Immediate(value));
5183 __ movl(Address(CpuRegister(RSP), destination.GetStackIndex()), imm);
5199 __ movaps(destination.AsFpuRegister<XmmRegister>(), source.AsFpuRegister<XmmRegister>());
5201 __ movss(Address(CpuRegister(RSP), destination.GetStackIndex()),
5205 __ movsd(Address(CpuRegister(RSP), destination.GetStackIndex()),
5212 __ movl(CpuRegister(TMP), Address(CpuRegister(RSP), mem));
5213 __ movl(Address(CpuRegister(RSP), mem), reg);
5214 __ movl(reg, CpuRegister(TMP));
5222 __ movl(CpuRegister(TMP), Address(CpuRegister(RSP), mem1 + stack_offset));
5223 __ movl(CpuRegister(ensure_scratch.GetRegister()),
5225 __ movl(Address(CpuRegister(RSP), mem2 + stack_offset), CpuRegister(TMP));
5226 __ movl(Address(CpuRegister(RSP), mem1 + stack_offset),
5231 __ movq(CpuRegister(TMP), reg1);
5232 __ movq(reg1, reg2);
5233 __ movq(reg2, CpuRegister(TMP));
5237 __ movq(CpuRegister(TMP), Address(CpuRegister(RSP), mem));
5238 __ movq(Address(CpuRegister(RSP), mem), reg);
5239 __ movq(reg, CpuRegister(TMP));
5247 __ movq(CpuRegister(TMP), Address(CpuRegister(RSP), mem1 + stack_offset));
5248 __ movq(CpuRegister(ensure_scratch.GetRegister()),
5250 __ movq(Address(CpuRegister(RSP), mem2 + stack_offset), CpuRegister(TMP));
5251 __ movq(Address(CpuRegister(RSP), mem1 + stack_offset),
5256 __ movl(CpuRegister(TMP), Address(CpuRegister(RSP), mem));
5257 __ movss(Address(CpuRegister(RSP), mem), reg);
5258 __ movd(reg, CpuRegister(TMP));
5262 __ movq(CpuRegister(TMP), Address(CpuRegister(RSP), mem));
5263 __ movsd(Address(CpuRegister(RSP), mem), reg);
5264 __ movd(reg, CpuRegister(TMP));
5287 __ movd(CpuRegister(TMP), source.AsFpuRegister<XmmRegister>());
5288 __ movaps(source.AsFpuRegister<XmmRegister>(), destination.AsFpuRegister<XmmRegister>());
5289 __ movd(destination.AsFpuRegister<XmmRegister>(), CpuRegister(TMP));
5305 __ pushq(CpuRegister(reg));
5310 __ popq(CpuRegister(reg));
5315 __ cmpl(Address(class_reg, mirror::Class::StatusOffset().Int32Value()),
5317 __ j(kLess, slow_path->GetEntryLabel());
5318 __ Bind(slow_path->GetExitLabel());
5356 __ movq(out, Address(current_method,
5368 __ testl(out, out);
5369 __ j(kEqual, slow_path->GetEntryLabel());
5374 __ Bind(slow_path->GetExitLabel());
5452 __ leal(out, Address::Absolute(CodeGeneratorX86_64::kDummy32BitOffset, /* no_rip */ false));
5460 __ movl(out, Immediate(address)); // Zero-extended.
5471 __ movq(out, Immediate(load->GetAddress()));
5491 __ movq(out, Address(out, mirror::Class::DexCacheStringsOffset().Uint32Value()));
5505 __ testl(out, out);
5506 __ j(kEqual, slow_path->GetEntryLabel());
5507 __ Bind(slow_path->GetExitLabel());
5523 __ gs()->movl(load->GetLocations()->Out().AsRegister<CpuRegister>(), GetExceptionTlsAddress());
5531 __ gs()->movl(GetExceptionTlsAddress(), Immediate(0));
5608 __ testl(obj, obj);
5609 __ j(kEqual, &zero);
5618 __ cmpl(out, cls.AsRegister<CpuRegister>());
5621 __ cmpl(out, Address(CpuRegister(RSP), cls.GetStackIndex()));
5625 __ j(kNotEqual, &zero);
5626 __ movl(out, Immediate(1));
5627 __ jmp(&done);
5629 __ setcc(kEqual, out);
5631 __ andl(out, Immediate(1));
5640 __ Bind(&loop);
5643 __ testl(out, out);
5645 __ j(kEqual, &done);
5647 __ cmpl(out, cls.AsRegister<CpuRegister>());
5650 __ cmpl(out, Address(CpuRegister(RSP), cls.GetStackIndex()));
5652 __ j(kNotEqual, &loop);
5653 __ movl(out, Immediate(1));
5655 __ jmp(&done);
5663 __ Bind(&loop);
5665 __ cmpl(out, cls.AsRegister<CpuRegister>());
5668 __ cmpl(out, Address(CpuRegister(RSP), cls.GetStackIndex()));
5670 __ j(kEqual, &success);
5673 __ testl(out, out);
5674 __ j(kNotEqual, &loop);
5676 __ jmp(&done);
5677 __ Bind(&success);
5678 __ movl(out, Immediate(1));
5680 __ jmp(&done);
5689 __ cmpl(out, cls.AsRegister<CpuRegister>());
5692 __ cmpl(out, Address(CpuRegister(RSP), cls.GetStackIndex()));
5694 __ j(kEqual, &exact_check);
5698 __ testl(out, out);
5700 __ j(kEqual, &done);
5701 __ cmpw(Address(out, primitive_offset), Immediate(Primitive::kPrimNot));
5702 __ j(kNotEqual, &zero);
5703 __ Bind(&exact_check);
5704 __ movl(out, Immediate(1));
5705 __ jmp(&done);
5711 __ cmpl(out, cls.AsRegister<CpuRegister>());
5714 __ cmpl(out, Address(CpuRegister(RSP), cls.GetStackIndex()));
5720 __ j(kNotEqual, slow_path->GetEntryLabel());
5721 __ movl(out, Immediate(1));
5723 __ jmp(&done);
5752 __ jmp(slow_path->GetEntryLabel());
5754 __ jmp(&done);
5761 __ Bind(&zero);
5762 __ xorl(out, out);
5766 __ Bind(&done);
5770 __ Bind(slow_path->GetExitLabel());
5838 __ testl(obj, obj);
5839 __ j(kEqual, &done);
5847 __ cmpl(temp, cls.AsRegister<CpuRegister>());
5850 __ cmpl(temp, Address(CpuRegister(RSP), cls.GetStackIndex()));
5854 __ j(kNotEqual, type_check_slow_path->GetEntryLabel());
5855 __ Bind(&done);
5863 __ testl(obj, obj);
5864 __ j(kEqual, &done);
5874 __ Bind(&loop);
5881 __ testl(temp, temp);
5882 __ j(kNotEqual, &compare_classes);
5891 __ jmp(type_check_slow_path->GetEntryLabel());
5893 __ Bind(&compare_classes);
5895 __ cmpl(temp, cls.AsRegister<CpuRegister>());
5898 __ cmpl(temp, Address(CpuRegister(RSP), cls.GetStackIndex()));
5900 __ j(kNotEqual, &loop);
5901 __ Bind(&done);
5909 __ testl(obj, obj);
5910 __ j(kEqual, &done);
5919 __ Bind(&loop);
5921 __ cmpl(temp, cls.AsRegister<CpuRegister>());
5924 __ cmpl(temp, Address(CpuRegister(RSP), cls.GetStackIndex()));
5926 __ j(kEqual, &done);
5933 __ testl(temp, temp);
5934 __ j(kNotEqual, &loop);
5943 __ jmp(type_check_slow_path->GetEntryLabel());
5944 __ Bind(&done);
5956 __ testl(obj, obj);
5957 __ j(kEqual, &done);
5967 __ cmpl(temp, cls.AsRegister<CpuRegister>());
5970 __ cmpl(temp, Address(CpuRegister(RSP), cls.GetStackIndex()));
5972 __ j(kEqual, &done);
5982 __ testl(temp, temp);
5983 __ j(kNotEqual, &check_non_primitive_component_type);
5992 __ jmp(type_check_slow_path->GetEntryLabel());
5994 __ Bind(&check_non_primitive_component_type);
5995 __ cmpw(Address(temp, primitive_offset), Immediate(Primitive::kPrimNot));
5996 __ j(kEqual, &done);
6001 __ jmp(type_check_slow_path->GetEntryLabel());
6002 __ Bind(&done);
6011 __ testl(obj, obj);
6012 __ j(kEqual, &done);
6036 __ jmp(type_check_slow_path->GetEntryLabel());
6037 __ Bind(&done);
6041 __ Bind(type_check_slow_path->GetExitLabel());
6099 __ andl(first.AsRegister<CpuRegister>(), second.AsRegister<CpuRegister>());
6101 __ orl(first.AsRegister<CpuRegister>(), second.AsRegister<CpuRegister>());
6104 __ xorl(first.AsRegister<CpuRegister>(), second.AsRegister<CpuRegister>());
6109 __ andl(first.AsRegister<CpuRegister>(), imm);
6111 __ orl(first.AsRegister<CpuRegister>(), imm);
6114 __ xorl(first.AsRegister<CpuRegister>(), imm);
6119 __ andl(first.AsRegister<CpuRegister>(), address);
6121 __ orl(first.AsRegister<CpuRegister>(), address);
6124 __ xorl(first.AsRegister<CpuRegister>(), address);
6141 __ andq(first_reg, Immediate(static_cast<int32_t>(value)));
6143 __ andq(first_reg, codegen_->LiteralInt64Address(value));
6146 __ andq(first_reg, Address(CpuRegister(RSP), second.GetStackIndex()));
6148 __ andq(first_reg, second.AsRegister<CpuRegister>());
6153 __ orq(first_reg, Immediate(static_cast<int32_t>(value)));
6155 __ orq(first_reg, codegen_->LiteralInt64Address(value));
6158 __ orq(first_reg, Address(CpuRegister(RSP), second.GetStackIndex()));
6160 __ orq(first_reg, second.AsRegister<CpuRegister>());
6166 __ xorq(first_reg, Immediate(static_cast<int32_t>(value)));
6168 __ xorq(first_reg, codegen_->LiteralInt64Address(value));
6171 __ xorq(first_reg, Address(CpuRegister(RSP), second.GetStackIndex()));
6173 __ xorq(first_reg, second.AsRegister<CpuRegister>());
6196 __ movl(maybe_temp.AsRegister<CpuRegister>(), out_reg);
6198 __ movl(out_reg, Address(out_reg, offset));
6204 __ movl(out_reg, Address(out_reg, offset));
6205 __ MaybeUnpoisonHeapReference(out_reg);
6226 __ movl(out_reg, Address(obj_reg, offset));
6232 __ movl(out_reg, Address(obj_reg, offset));
6233 __ MaybeUnpoisonHeapReference(out_reg);
6253 __ movl(root_reg, address);
6255 __ Bind(fixup_label);
6270 __ gs()->cmpl(Address::Absolute(Thread::IsGcMarkingOffset<kX86_64WordSize>().Int32Value(),
6273 __ j(kNotEqual, slow_path->GetEntryLabel());
6274 __ Bind(slow_path->GetExitLabel());
6279 __ leaq(root_reg, address);
6281 __ Bind(fixup_label);
6289 __ movl(root_reg, address);
6291 __ Bind(fixup_label);
6368 __ movl(temp_reg, Address(obj, monitor_offset));
6376 __ shrl(temp_reg, Immediate(LockWord::kReadBarrierStateShift));
6377 __ andl(temp_reg, Immediate(LockWord::kReadBarrierStateMask));
6388 __ movl(ref_reg, src);
6391 __ MaybeUnpoisonHeapReference(ref_reg);
6400 __ cmpl(temp_reg, Immediate(ReadBarrier::gray_ptr_));
6401 __ j(kEqual, slow_path->GetEntryLabel());
6402 __ Bind(slow_path->GetExitLabel());
6428 __ jmp(slow_path->GetEntryLabel());
6429 __ Bind(slow_path->GetExitLabel());
6446 __ UnpoisonHeapReference(out.AsRegister<CpuRegister>());
6463 __ jmp(slow_path->GetEntryLabel());
6464 __ Bind(slow_path->GetExitLabel());
6506 __ cmpl(value_reg_in, Immediate(lower_bound));
6507 __ j(first_condition, codegen_->GetLabelOf(default_block));
6508 __ j(kEqual, codegen_->GetLabelOf(successors[0]));
6520 __ cmpl(value_reg_in, Immediate(compare_to_value));
6522 __ j(first_condition, codegen_->GetLabelOf(successors[index]));
6524 __ j(kEqual, codegen_->GetLabelOf(successors[index + 1]));
6530 __ cmpl(value_reg_in, Immediate(static_cast<int32_t>(lower_bound + index)));
6531 __ j(kEqual, codegen_->GetLabelOf(successors[index]));
6536 __ jmp(codegen_->GetLabelOf(default_block));
6544 __ leal(temp_reg, Address(value_reg_in, -lower_bound));
6550 __ cmpl(value_reg, Immediate(num_entries - 1));
6551 __ j(kAbove, codegen_->GetLabelOf(default_block));
6555 __ leaq(base_reg, codegen_->LiteralCaseTable(switch_instr));
6558 __ movsxd(temp_reg, Address(base_reg, value_reg, TIMES_4, 0));
6561 __ addq(temp_reg, base_reg);
6564 __ jmp(temp_reg);
6569 __ xorl(dest, dest);
6571 __ movl(dest, Immediate(value));
6578 __ xorl(dest, dest);
6581 __ movl(dest, Immediate(static_cast<int32_t>(value)));
6583 __ movq(dest, Immediate(value));
6589 __ xorps(dest, dest);
6591 __ movss(dest, LiteralInt32Address(value));
6597 __ xorpd(dest, dest);
6599 __ movsd(dest, LiteralInt64Address(value));
6613 __ testl(dest, dest);
6615 __ cmpl(dest, Immediate(value));
6622 __ testq(dest, dest);
6624 __ cmpq(dest, Immediate(static_cast<int32_t>(value)));
6628 __ cmpq(dest, LiteralInt64Address(value));
6636 __ movq(Address(CpuRegister(RSP), dest.GetStackIndex()),
6640 __ movq(Address(CpuRegister(RSP), dest.GetStackIndex()), CpuRegister(TMP));
6731 AssemblerFixup* fixup = new (GetGraph()->GetArena()) RIPFixup(*this, __ AddDouble(v));
6736 AssemblerFixup* fixup = new (GetGraph()->GetArena()) RIPFixup(*this, __ AddFloat(v));
6741 AssemblerFixup* fixup = new (GetGraph()->GetArena()) RIPFixup(*this, __ AddInt32(v));
6746 AssemblerFixup* fixup = new (GetGraph()->GetArena()) RIPFixup(*this, __ AddInt64(v));
6786 __ movq(addr_low, Immediate(v_32));
6792 __ movl(addr_low, Immediate(low_v));
6794 __ movl(addr_high, Immediate(high_v));
6798 #undef __