Lines Matching defs:dst
97 V8_INLINE void TransferStackSlot(const VarState& dst, const VarState& src) {
98 DCHECK(CheckCompatibleStackSlotTypes(dst.kind(), src.kind()));
99 if (dst.is_reg()) {
100 LoadIntoRegister(dst.reg(), src, src.offset());
103 if (dst.is_const()) {
104 DCHECK_EQ(dst.i32_const(), src.i32_const());
107 DCHECK(dst.is_stack());
110 if (src.offset() != dst.offset()) {
111 asm_->MoveStackValue(dst.offset(), src.offset(), src.kind());
115 asm_->Spill(dst.offset(), src.reg(), src.kind());
118 asm_->Spill(dst.offset(), src.constant());
123 V8_INLINE void LoadIntoRegister(LiftoffRegister dst,
128 LoadStackSlot(dst, src_offset, src.kind());
131 DCHECK_EQ(dst.reg_class(), src.reg_class());
132 if (dst != src.reg()) MoveRegister(dst, src.reg(), src.kind());
135 LoadConstant(dst, src.constant());
140 void LoadI64HalfIntoRegister(LiftoffRegister dst,
149 LoadI64HalfStackSlot(dst, offset, half);
154 if (dst != src_half) MoveRegister(dst, src_half, kI32);
161 LoadConstant(dst, WasmValue(value));
166 void MoveRegister(LiftoffRegister dst, LiftoffRegister src, ValueKind kind) {
167 DCHECK_NE(dst, src);
168 DCHECK_EQ(dst.reg_class(), src.reg_class());
172 if (dst.low() != src.low()) MoveRegister(dst.low(), src.low(), kI32);
173 if (dst.high() != src.high()) MoveRegister(dst.high(), src.high(), kI32);
178 if (dst.low() != src.low()) {
179 MoveRegister(dst.low(), src.low(), kF64);
180 MoveRegister(dst.high(), src.high(), kF64);
184 if (move_dst_regs_.has(dst)) {
185 DCHECK_EQ(register_move(dst)->src, src);
187 DCHECK_IMPLIES(!dst.is_fp(), register_move(dst)->kind == kind);
191 if (kind == kF64) register_move(dst)->kind = kF64;
194 move_dst_regs_.set(dst);
196 *register_move(dst) = {src, kind};
199 void LoadConstant(LiftoffRegister dst, WasmValue value) {
200 DCHECK(!load_dst_regs_.has(dst));
201 load_dst_regs_.set(dst);
202 if (dst.is_gp_pair()) {
205 *register_load(dst.low()) =
207 *register_load(dst.high()) =
210 *register_load(dst) = RegisterLoad::Const(value);
214 void LoadStackSlot(LiftoffRegister dst, uint32_t stack_offset,
216 if (load_dst_regs_.has(dst)) {
218 // slots, and then we reload them later into the same dst register.
222 load_dst_regs_.set(dst);
223 if (dst.is_gp_pair()) {
225 *register_load(dst.low()) =
227 *register_load(dst.high()) =
229 } else if (dst.is_fp_pair()) {
234 *register_load(dst.low()) = RegisterLoad::Stack(stack_offset, kind);
235 *register_load(dst.high()) = RegisterLoad::Nop();
237 *register_load(dst) = RegisterLoad::Stack(stack_offset, kind);
241 void LoadI64HalfStackSlot(LiftoffRegister dst, int offset, RegPairHalf half) {
242 if (load_dst_regs_.has(dst)) {
244 // slots, and then we reload them later into the same dst register.
248 load_dst_regs_.set(dst);
249 *register_load(dst) = RegisterLoad::HalfStack(offset, half);
282 void ExecuteMove(LiftoffRegister dst) {
283 RegisterMove* move = register_move(dst);
284 DCHECK_EQ(0, *src_reg_use_count(dst));
285 asm_->Move(dst, move->src, move->kind);
286 ClearExecutedMove(dst);
289 void ClearExecutedMove(LiftoffRegister dst) {
290 DCHECK(move_dst_regs_.has(dst));
291 move_dst_regs_.clear(dst);
292 RegisterMove* move = register_move(dst);
302 // Execute all moves whose {dst} is not being used as src in another move.
305 for (LiftoffRegister dst : move_dst_regs_) {
307 if (!move_dst_regs_.has(dst)) continue;
308 if (*src_reg_use_count(dst)) continue;
309 ExecuteMove(dst);
317 LiftoffRegister dst = move_dst_regs_.GetFirstRegSet();
318 RegisterMove* move = register_move(dst);
323 LoadStackSlot(dst, last_spill_offset, move->kind);
324 ClearExecutedMove(dst);
329 for (LiftoffRegister dst : load_dst_regs_) {
330 RegisterLoad* load = register_load(dst);
335 asm_->LoadConstant(dst, load->kind == kI64
341 asm_->Fill(LiftoffRegister::ForFpPair(dst.fp()), load->value,
344 asm_->Fill(dst, load->value, load->kind);
348 // Half of a register pair, {dst} must be a gp register.
349 asm_->FillI64Half(dst.gp(), load->value, kLowWord);
352 // Half of a register pair, {dst} must be a gp register.
353 asm_->FillI64Half(dst.gp(), load->value, kHighWord);
363 void Add(LiftoffRegister src, LiftoffRegister dst) {
365 DCHECK_EQ(previous, dst);
369 map_.emplace_back(dst);
382 // {map_} holds pairs of <src, dst>.
643 LiftoffRegister dst = GetUnusedRegister(kGpReg, {});
645 FillI64Half(dst.gp(), slot.offset(), half);
646 return dst;
652 LoadConstant(dst, WasmValue(half_word));
653 return dst;
1129 void LiftoffAssembler::Move(LiftoffRegister dst, LiftoffRegister src,
1131 DCHECK_EQ(dst.reg_class(), src.reg_class());
1132 DCHECK_NE(dst, src);
1133 if (kNeedI64RegPair && dst.is_gp_pair()) {
1136 StackTransferRecipe(this).MoveRegister(dst, src, kind);
1137 } else if (kNeedS128RegPair && dst.is_fp_pair()) {
1140 Move(dst.low_fp(), src.low_fp(), kind);
1141 } else if (dst.is_gp()) {
1142 Move(dst.gp(), src.gp(), kind);
1144 Move(dst.fp(), src.fp(), kind);
1152 if (tuple.dst == tuple.src) continue;
1153 stack_transfers.MoveRegister(tuple.dst, tuple.src, tuple.kind);