Lines Matching defs:out
305 Location out = locations->Out();
306 if (out.IsValid()) {
307 DCHECK(out.IsRegister() && !locations->GetLiveRegisters()->ContainsCoreRegister(out.reg()));
309 arm64_codegen->MoveLocation(out, calling_convention.GetReturnLocation(type), type);
341 DCHECK(!locations->GetLiveRegisters()->ContainsCoreRegister(locations->Out().reg()));
354 arm64_codegen->MoveLocation(locations->Out(), calling_convention.GetReturnLocation(type), type);
440 : locations->Out();
442 || !locations->GetLiveRegisters()->ContainsCoreRegister(locations->Out().reg()));
466 arm64_codegen->MoveLocation(locations->Out(), ret_loc, ret_type);
579 ReadBarrierMarkSlowPathARM64(HInstruction* instruction, Location out, Location obj)
580 : SlowPathCodeARM64(instruction), out_(out), obj_(obj) {
629 Location out,
635 out_(out),
641 // If `obj` is equal to `out` or `ref`, it means the initial object
645 // __ Ldr(out, HeapOperand(out, class_offset);
650 DCHECK(!obj.Equals(out)) << "obj=" << obj << " out=" << out;
810 ReadBarrierForRootSlowPathARM64(HInstruction* instruction, Location out, Location root)
811 : SlowPathCodeARM64(instruction), out_(out), root_(root) {
1628 Location out = locations->Out();
1638 // /* HeapReference<Object> */ out = *(base + offset)
1645 out,
1667 codegen_->MaybeGenerateReadBarrierSlow(instruction, out, out, base_loc, offset);
1896 Register out = OutputRegister(instruction);
1927 __ Add(out, left, right_operand);
1930 __ And(out, left, right_operand);
1934 __ Neg(out, right_operand);
1937 __ Orr(out, left, right_operand);
1940 __ Sub(out, left, right_operand);
1943 __ Eor(out, left, right_operand);
1995 // This fixup should be carried out for all multiply-accumulate instructions:
2054 Location out = locations->Out();
2070 instruction, out, obj.W(), offset, index, temp, /* needs_null_check */ true);
2106 codegen_->MaybeGenerateReadBarrierSlow(instruction, out, out, obj_loc, offset);
2108 codegen_->MaybeGenerateReadBarrierSlow(instruction, out, out, obj_loc, offset, index);
2252 // restored afterwards). So in this case, we bail out and
2484 Register res = RegisterFrom(locations->Out(), instruction->GetType());
2524 Register out = OutputRegister(instruction);
2530 __ Mov(out, 0);
2533 __ Mov(out, dividend);
2535 __ Neg(out, dividend);
2547 Register out = OutputRegister(instruction);
2554 Register temp = temps.AcquireSameSizeAs(out);
2559 __ Csel(out, temp, dividend, lt);
2561 __ Asr(out, out, ctz_imm);
2563 __ Neg(out, Operand(out, ASR, ctz_imm));
2569 __ Add(out, dividend, temp);
2570 __ And(out, out, abs_imm - 1);
2571 __ Sub(out, out, temp);
2582 Register out = OutputRegister(instruction);
2594 Register temp = temps.AcquireSameSizeAs(out);
2616 __ Sub(out, temp, Operand(temp, ASR, type == Primitive::kPrimLong ? 63 : 31));
2620 Register temp_imm = temps.AcquireSameSizeAs(out);
2622 __ Msub(out, temp, temp_imm, dividend);
2632 Register out = OutputRegister(instruction);
2652 __ Sdiv(out, dividend, divisor);
2655 Register temp = temps.AcquireSameSizeAs(out);
2657 __ Msub(out, temp, divisor, dividend);
3128 // The "out" register is used as a temporary, so it overlaps with the inputs.
3144 Location out_loc = locations->Out();
3145 Register out = OutputRegister(instruction);
3163 // /* HeapReference<Class> */ out = obj->klass_
3168 __ Cmp(out, cls);
3169 __ Cset(out, eq);
3181 // /* HeapReference<Class> */ out = out->super_class_
3183 // If `out` is null, we use it for the result, and jump to `done`.
3184 __ Cbz(out, &done);
3185 __ Cmp(out, cls);
3187 __ Mov(out, 1);
3198 __ Cmp(out, cls);
3200 // /* HeapReference<Class> */ out = out->super_class_
3202 __ Cbnz(out, &loop);
3203 // If `out` is null, we use it for the result, and jump to `done`.
3206 __ Mov(out, 1);
3216 __ Cmp(out, cls);
3219 // /* HeapReference<Class> */ out = out->component_type_
3221 // If `out` is null, we use it for the result, and jump to `done`.
3222 __ Cbz(out, &done);
3223 __ Ldrh(out, HeapOperand(out, primitive_offset));
3225 __ Cbnz(out, &zero);
3227 __ Mov(out, 1);
3233 __ Cmp(out, cls);
3239 __ Mov(out, 1);
3280 __ Mov(out, 0);
3935 Location out_loc = cls->GetLocations()->Out();
3936 Register out = OutputRegister(cls);
3941 // /* GcRoot<mirror::Class> */ out = current_method->declaring_class_
3946 // /* GcRoot<mirror::Class>[] */ out =
3948 __ Ldr(out.X(), MemOperand(current_method, resolved_types_offset.Int32Value()));
3949 // /* GcRoot<mirror::Class> */ out = out[type_index]
3951 cls, out_loc, out.X(), CodeGenerator::GetCacheOffset(cls->GetTypeIndex()));
3959 __ Cbz(out, slow_path->GetEntryLabel());
3962 GenerateClassInitializationCheck(slow_path, out);
4038 Location out_loc = load->GetLocations()->Out();
4039 Register out = OutputRegister(load);
4044 __ Ldr(out, codegen_->DeduplicateBootImageStringLiteral(load->GetDexFile(),
4056 __ adrp(out.X(), /* offset placeholder */ 0);
4064 __ add(out.X(), out.X(), Operand(/* offset placeholder */ 0));
4071 __ Ldr(out.W(), codegen_->DeduplicateBootImageAddressLiteral(load->GetAddress()));
4085 __ Ldr(out.X(), codegen_->DeduplicateDexCacheAddressLiteral(base_address));
4086 GenerateGcRootFieldLoad(load, out_loc, out.X(), offset);
4097 __ adrp(out.X(), /* offset placeholder */ 0);
4102 GenerateGcRootFieldLoad(load, out_loc, out.X(), /* offset placeholder */ 0, ldr_label);
4107 // /* GcRoot<mirror::Class> */ out = current_method->declaring_class_
4110 // /* GcRoot<mirror::String>[] */ out = out->dex_cache_strings_
4111 __ Ldr(out.X(), HeapOperand(out, mirror::Class::DexCacheStringsOffset().Uint32Value()));
4112 // /* GcRoot<mirror::String> */ out = out[string_index]
4114 load, out_loc, out.X(), CodeGenerator::GetCacheOffset(load->GetStringIndex()));
4125 __ Cbz(out, slow_path->GetEntryLabel());
4754 // make sure we don't emit it if the target may run out of range.
4805 // Jump to default block if index is out of the range.
4826 Location out,
4830 Register out_reg = RegisterFrom(out, type);
4835 // /* HeapReference<Object> */ out = *(out + offset)
4837 out,
4845 // Save the value of `out` into `maybe_temp` before overwriting it
4849 // /* HeapReference<Object> */ out = *(out + offset)
4851 codegen_->GenerateReadBarrierSlow(instruction, out, out, maybe_temp, offset);
4855 // /* HeapReference<Object> */ out = *(out + offset)
4862 Location out,
4867 Register out_reg = RegisterFrom(out, type);
4873 // /* HeapReference<Object> */ out = *(obj + offset)
4875 out,
4883 // /* HeapReference<Object> */ out = *(obj + offset)
4885 codegen_->GenerateReadBarrierSlow(instruction, out, out, obj, offset);
4889 // /* HeapReference<Object> */ out = *(obj + offset)
5115 Location out,
5125 // reference will be carried out by the runtime within the slow
5134 ReadBarrierForHeapReferenceSlowPathARM64(instruction, out, ref, obj, offset, index);
5142 Location out,
5153 GenerateReadBarrierSlow(instruction, out, ref, obj, offset, index);
5155 out));
5160 Location out,
5169 new (GetGraph()->GetArena()) ReadBarrierForRootSlowPathARM64(instruction, out, root);
5188 __ Ldr(XRegisterFrom(locations->Out()),
5193 __ Ldr(XRegisterFrom(locations->Out()), MemOperand(XRegisterFrom(locations->InAt(0)),
5195 __ Ldr(XRegisterFrom(locations->Out()),
5196 MemOperand(XRegisterFrom(locations->Out()), method_offset));
