Lines Matching defs:out
322 Location out = locations->Out();
354 if (out.IsValid()) {
355 DCHECK(out.IsRegister() && !locations->GetLiveRegisters()->ContainsCoreRegister(out.reg()));
357 arm64_codegen->MoveLocation(out, calling_convention.GetReturnLocation(type), type);
362 DCHECK(out.IsValid());
376 __ str(RegisterFrom(locations->Out(), Primitive::kPrimNot),
411 DCHECK(!locations->GetLiveRegisters()->ContainsCoreRegister(locations->Out().reg()));
428 arm64_codegen->MoveLocation(locations->Out(), calling_convention.GetReturnLocation(type), type);
446 __ str(RegisterFrom(locations->Out(), Primitive::kPrimNot),
538 || !locations->GetLiveRegisters()->ContainsCoreRegister(locations->Out().reg()));
562 arm64_codegen->MoveLocation(locations->Out(), ret_loc, ret_type);
1172 Location out,
1178 out_(out),
1184 // If `obj` is equal to `out` or `ref`, it means the initial object
1188 // __ Ldr(out, HeapOperand(out, class_offset);
1193 DCHECK(!obj.Equals(out)) << "obj=" << obj << " out=" << out;
1358 ReadBarrierForRootSlowPathARM64(HInstruction* instruction, Location out, Location root)
1359 : SlowPathCodeARM64(instruction), out_(out), root_(root) {
2332 Location out = locations->Out();
2339 // /* HeapReference<Object> */ out = *(base + offset)
2347 out,
2371 codegen_->MaybeGenerateReadBarrierSlow(instruction, out, out, base_loc, offset);
2603 Register out = OutputRegister(instruction);
2633 __ Add(out, left, right_operand);
2636 __ And(out, left, right_operand);
2640 __ Neg(out, right_operand);
2643 __ Orr(out, left, right_operand);
2646 __ Sub(out, left, right_operand);
2649 __ Eor(out, left, right_operand);
2680 // data offset constant generation out of the loop and reduce the critical path length in the
2726 // This fixup should be carried out for all multiply-accumulate instructions:
2802 Location out = locations->Out();
2826 out,
2835 instruction, out, obj.W(), offset, index, temp, /* needs_null_check */ false);
2920 codegen_->MaybeGenerateReadBarrierSlow(instruction, out, out, obj_loc, offset);
2922 codegen_->MaybeGenerateReadBarrierSlow(instruction, out, out, obj_loc, offset, index);
2936 vixl::aarch64::Register out = OutputRegister(instruction);
2940 __ Ldr(out, HeapOperand(InputRegisterAt(instruction, 0), offset));
2943 // Mask out compression flag from String's array length.
2945 __ Lsr(out.W(), out.W(), 1u);
3299 Register res = RegisterFrom(locations->Out(), instruction->GetType());
3339 Register out = OutputRegister(instruction);
3345 __ Mov(out, 0);
3348 __ Mov(out, dividend);
3350 __ Neg(out, dividend);
3362 Register out = OutputRegister(instruction);
3369 Register temp = temps.AcquireSameSizeAs(out);
3374 __ Csel(out, temp, dividend, lt);
3376 __ Asr(out, out, ctz_imm);
3378 __ Neg(out, Operand(out, ASR, ctz_imm));
3384 __ Add(out, dividend, temp);
3385 __ And(out, out, abs_imm - 1);
3386 __ Sub(out, out, temp);
3397 Register out = OutputRegister(instruction);
3409 Register temp = temps.AcquireSameSizeAs(out);
3431 __ Sub(out, temp, Operand(temp, ASR, type == Primitive::kPrimLong ? 63 : 31));
3435 Register temp_imm = temps.AcquireSameSizeAs(out);
3437 __ Msub(out, temp, temp_imm, dividend);
3447 Register out = OutputRegister(instruction);
3467 __ Sdiv(out, dividend, divisor);
3470 Register temp = temps.AcquireSameSizeAs(out);
3472 __ Msub(out, temp, divisor, dividend);
3930 // The "out" register is used as a temporary, so it overlaps with the inputs.
3943 Location out_loc = locations->Out();
3944 Register out = OutputRegister(instruction);
3964 // /* HeapReference<Class> */ out = obj->klass_
3971 __ Cmp(out, cls);
3972 __ Cset(out, eq);
3980 // /* HeapReference<Class> */ out = obj->klass_
3991 // /* HeapReference<Class> */ out = out->super_class_
3997 // If `out` is null, we use it for the result, and jump to `done`.
3998 __ Cbz(out, &done);
3999 __ Cmp(out, cls);
4001 __ Mov(out, 1);
4009 // /* HeapReference<Class> */ out = obj->klass_
4019 __ Cmp(out, cls);
4021 // /* HeapReference<Class> */ out = out->super_class_
4027 __ Cbnz(out, &loop);
4028 // If `out` is null, we use it for the result, and jump to `done`.
4031 __ Mov(out, 1);
4039 // /* HeapReference<Class> */ out = obj->klass_
4048 __ Cmp(out, cls);
4051 // /* HeapReference<Class> */ out = out->component_type_
4057 // If `out` is null, we use it for the result, and jump to `done`.
4058 __ Cbz(out, &done);
4059 __ Ldrh(out, HeapOperand(out, primitive_offset));
4061 __ Cbnz(out, &zero);
4063 __ Mov(out, 1);
4070 // /* HeapReference<Class> */ out = obj->klass_
4077 __ Cmp(out, cls);
4083 __ Mov(out, 1);
4124 __ Mov(out, 0);
4722 vixl::aarch64::Register out,
4724 DCHECK(out.IsX());
4728 __ add(out, base, Operand(/* offset placeholder */ 0));
4732 vixl::aarch64::Register out,
4737 __ ldr(out, MemOperand(base, /* offset placeholder */ 0));
4902 Location out_loc = cls->GetLocations()->Out();
4903 Register out = OutputRegister(cls);
4915 // /* GcRoot<mirror::Class> */ out = current_method->declaring_class_
4931 codegen_->EmitAdrpPlaceholder(adrp_label, out.X());
4935 codegen_->EmitAddPlaceholder(add_label, out.X(), out.X());
4943 __ Ldr(out.W(), codegen_->DeduplicateBootImageAddressLiteral(address));
4956 // /* GcRoot<mirror::Class> */ out = *(base_address + offset) /* PC-relative */
4967 __ Ldr(out, codegen_->DeduplicateJitClassLiteral(cls->GetDexFile(),
4972 out.X(),
4991 __ Cbz(out, slow_path->GetEntryLabel());
4994 GenerateClassInitializationCheck(slow_path, out);
5069 Register out = OutputRegister(load);
5070 Location out_loc = load->GetLocations()->Out();
5079 codegen_->EmitAdrpPlaceholder(adrp_label, out.X());
5083 codegen_->EmitAddPlaceholder(add_label, out.X(), out.X());
5090 __ Ldr(out.W(), codegen_->DeduplicateBootImageAddressLiteral(address));
5104 // /* GcRoot<mirror::String> */ out = *(base_address + offset) /* PC-relative */
5114 __ Cbz(out.X(), slow_path->GetEntryLabel());
5119 __ Ldr(out, codegen_->DeduplicateJitStringLiteral(load->GetDexFile(),
5124 out.X(),
5136 DCHECK_EQ(calling_convention.GetRegisterAt(0).GetCode(), out.GetCode());
5770 // make sure we don't emit it if the target may run out of range.
5821 // Jump to default block if index is out of the range.
5843 Location out,
5848 Register out_reg = RegisterFrom(out, type);
5853 // /* HeapReference<Object> */ out = *(out + offset)
5855 out,
5863 // Save the value of `out` into `maybe_temp` before overwriting it
5868 // /* HeapReference<Object> */ out = *(out + offset)
5870 codegen_->GenerateReadBarrierSlow(instruction, out, out, maybe_temp, offset);
5874 // /* HeapReference<Object> */ out = *(out + offset)
5882 Location out,
5888 Register out_reg = RegisterFrom(out, type);
5894 // /* HeapReference<Object> */ out = *(obj + offset)
5896 out,
5904 // /* HeapReference<Object> */ out = *(obj + offset)
5906 codegen_->GenerateReadBarrierSlow(instruction, out, out, obj, offset);
5910 // /* HeapReference<Object> */ out = *(obj + offset)
6385 Location out,
6395 // reference will be carried out by the runtime within the slow
6404 ReadBarrierForHeapReferenceSlowPathARM64(instruction, out, ref, obj, offset, index);
6412 Location out,
6423 GenerateReadBarrierSlow(instruction, out, ref, obj, offset, index);
6425 GetAssembler()->UnpoisonHeapReference(WRegisterFrom(out));
6430 Location out,
6439 new (GetGraph()->GetArena()) ReadBarrierForRootSlowPathARM64(instruction, out, root);
6458 __ Ldr(XRegisterFrom(locations->Out()),
6463 __ Ldr(XRegisterFrom(locations->Out()), MemOperand(XRegisterFrom(locations->InAt(0)),
6465 __ Ldr(XRegisterFrom(locations->Out()),
6466 MemOperand(XRegisterFrom(locations->Out()), method_offset));
