Lines Matching defs:kind
392 [](ValueType type) { return type.kind(); });
405 ValueKind kind;
570 V8_INLINE bool CheckSupportedType(FullDecoder* decoder, ValueKind kind,
572 if (V8_LIKELY(supported_types_.contains(kind))) return true;
573 return MaybeBailoutForUnsupportedType(decoder, kind, context);
577 ValueKind kind,
579 DCHECK(!supported_types_.contains(kind));
583 if (supported_types_.contains(kind)) return true;
586 switch (kind) {
601 SNPrintF(buffer, "%s %s", name(kind), context);
633 ValueKind kind = decoder->local_type(i).kind();
634 __ set_local_kind(i, kind);
647 uint32_t ProcessParameter(ValueKind kind, uint32_t input_idx) {
648 const bool needs_pair = needs_gp_reg_pair(kind);
649 const ValueKind reg_kind = needs_pair ? kI32 : kind;
678 __ PushRegister(kind, reg);
777 ValueKind kind = __ local_kind(param_idx);
778 if (kind != kI32 && kind != kI64) return true;
876 ValueKind kind = __ local_kind(param_idx);
877 has_refs |= is_reference(kind);
878 __ PushStack(kind);
889 ValueKind kind = __ local_kind(local_index);
890 if (is_reference(kind)) {
892 LiftoffRegister(null_ref_reg), kind);
899 ValueKind kind = __ local_kind(param_idx);
901 DCHECK(kind == kI32 || kind == kI64);
902 __ PushConstant(kind, int32_t{0});
958 __ Spill(entry.offset, entry.reg, entry.kind);
1004 __ Fill(entry.reg, entry.offset, entry.kind);
1244 DCHECK_EQ(__ cache_state()->stack_state.back().kind(), kRef);
1276 DCHECK_EQ(exception.kind(), kRef);
1577 template <ValueKind kind>
1584 auto sig = MakeSig::Params(kind);
1585 GenerateCCall(&dst, &sig, kind, &src, ext_ref);
1587 EmitUnOp<kind, kind>(emit_with_c_fallback);
1633 #define CASE_FLOAT_UNOP(opcode, kind, fn) \
1635 return EmitUnOp<k##kind, k##kind>(&LiftoffAssembler::emit_##fn);
1636 #define CASE_FLOAT_UNOP_WITH_CFALLBACK(opcode, kind, fn) \
1638 return EmitFloatUnOpWithCFallback<k##kind>(&LiftoffAssembler::emit_##fn, \
1877 #define CASE_CCALL_BINOP(opcode, kind, ext_ref_fn) \
1879 return EmitBinOp<k##kind, k##kind>( \
1883 ValueKind sig_kinds[] = {k##kind, k##kind, k##kind}; \
1884 const bool out_via_stack = k##kind == kI64; \
2185 __ PushRegister(type.kind(), null);
2219 ValueKind return_kind = decoder->sig_->GetReturn(0).kind();
2275 local_slot.kind(), __ NextSpillOffset(local_slot.kind()));
2284 auto rc = reg_class_for(local_slot.kind());
2288 __ Fill(reg, local_slot.offset(), local_slot.kind());
2296 ValueKind kind = dst_slot->kind();
2300 __ Fill(dst_slot->reg(), src_slot.offset(), kind);
2306 DCHECK(CheckCompatibleStackSlotTypes(kind, __ local_kind(local_index)));
2307 RegClass rc = reg_class_for(kind);
2309 __ Fill(dst_reg, src_slot.offset(), kind);
2310 *dst_slot = LiftoffAssembler::VarState(kind, dst_reg, dst_slot->offset());
2405 ValueKind kind = global->type.kind();
2406 if (!CheckSupportedType(decoder, kind, "global")) {
2410 if (is_reference(kind)) {
2418 __ PushRegister(kind, LiftoffRegister(base));
2432 __ PushRegister(kind, LiftoffRegister(value));
2439 pinned.set(__ GetUnusedRegister(reg_class_for(kind), pinned));
2440 LoadType type = LoadType::ForValueKind(kind);
2442 __ PushRegister(kind, value);
2448 ValueKind kind = global->type.kind();
2449 if (!CheckSupportedType(decoder, kind, "global")) {
2453 if (is_reference(kind)) {
2481 StoreType type = StoreType::ForValueKind(kind);
2496 ValueKind result_kind = env_->module->tables[imm.index].type.kind();
2521 ValueKind table_kind = env_->module->tables[imm.index].type.kind();
2572 ValueKind kind = __ cache_state()->stack_state.end()[-1].kind();
2574 kind, __ cache_state()->stack_state.end()[-2].kind()));
2579 if (!__ emit_select(dst, condition, true_value, false_value, kind)) {
2584 if (dst != true_value) __ Move(dst, true_value, kind);
2588 if (dst != false_value) __ Move(dst, false_value, kind);
2591 __ PushRegister(kind, dst);
2761 slot.offset(), slot.reg(), slot.kind()});
2998 ValueKind kind = type.value_type().kind();
2999 RegClass rc = reg_class_for(kind);
3000 if (!CheckSupportedType(decoder, kind, "load")) return;
3017 __ PushRegister(kind, value);
3039 __ PushRegister(kind, value);
3132 ValueKind kind = type.value_type().kind();
3133 if (!CheckSupportedType(decoder, kind, "store")) return;
3304 DCHECK(CheckCompatibleStackSlotTypes(slot.kind(), type.kind()));
3406 __ emit_cond_jump(kUnequal, &cont_false, ref_object.type.kind(), ref.gp(),
3431 __ emit_cond_jump(kEqual, &cont_false, ref_object.type.kind(), ref.gp(),
4068 #define CASE_SIMD_EXTRACT_LANE_OP(opcode, kind, fn) \
4070 EmitSimdExtractLaneOp<kS128, k##kind>( \
4085 #define CASE_SIMD_REPLACE_LANE_OP(opcode, kind, fn) \
4087 EmitSimdReplaceLaneOp<k##kind>( \
4243 switch (type.kind()) {
4296 void LoadExceptionValue(ValueKind kind, LiftoffRegister values_array,
4298 RegClass rc = reg_class_for(kind);
4300 switch (kind) {
4351 __ PushRegister(kind, value);
4365 LoadExceptionValue(param.kind(), values_array, &index, pinned);
4483 ValueKind kind = type.value_type().kind();
4494 RegClass rc = reg_class_for(kind);
4497 __ PushRegister(kind, value);
4511 ValueKind result_kind = type.value_type().kind();
4582 __ PushRegister(type.value_type().kind(), result);
4585 ValueKind result_kind = type.value_type().kind();
4631 void AtomicWait(FullDecoder* decoder, ValueKind kind,
4635 BoundsCheckMem(decoder, value_kind_size(kind), imm.offset, full_index,
4639 AlignmentCheckMem(decoder, value_kind_size(kind), imm.offset, index_reg,
4667 auto target = kTargets[kNeedI64RegPair][kind == kI32];
4669 CallRuntimeStub(target, MakeSig::Params(kPointerKind, kind, kI64),
5194 MakeSig::Returns(kRef).Params(rtt.type.kind()), {rtt_value},
5204 ValueKind field_kind = imm.struct_type->field(i).kind();
5240 ValueKind field_kind = struct_type->field(field.field_imm.index).kind();
5257 ValueKind field_kind = struct_type->field(field.field_imm.index).kind();
5277 ValueKind elem_kind = imm.array_type->element_type().kind();
5339 ArrayNew(decoder, imm, rtt.type.kind(), true);
5345 ArrayNew(decoder, imm, rtt.type.kind(), false);
5356 ValueKind elem_kind = imm.array_type->element_type().kind();
5375 DCHECK_EQ(reg_class_for(imm.array_type->element_type().kind()),
5381 ValueKind elem_kind = imm.array_type->element_type().kind();
5424 ValueKind rtt_kind = rtt.type.kind();
5425 ValueKind elem_kind = imm.array_type->element_type().kind();
5585 obj.type.kind(), obj_reg.gp(), tmp1.gp());
5593 __ emit_cond_jump(kEqual, &match, rtt.type.kind(), tmp1.gp(), rtt_reg.gp());
5619 __ emit_cond_jump(kUnequal, no_match, rtt.type.kind(), tmp1.gp(),
5656 __ PushRegister(obj.type.kind(), obj_reg);
5673 __ PushRegister(rtt.type.is_bottom() ? kBottom : obj.type.kind(), obj_reg);
5679 __ PushRegister(obj.type.kind(), obj_reg);
5694 __ PushRegister(obj.type.kind(), obj_reg);
6318 int offset, ValueKind kind, bool is_signed,
6320 if (is_reference(kind)) {
6323 // Primitive kind.
6324 LoadType load_type = LoadType::ForValueKind(kind, is_signed);
6331 ValueKind kind) {
6332 if (is_reference(kind)) {
6335 // Primitive kind.
6336 StoreType store_type = StoreType::ForValueKind(kind);
6341 void SetDefaultValue(LiftoffRegister reg, ValueKind kind,
6343 DCHECK(is_defaultable(kind));
6344 switch (kind) {
6426 void CheckNan(LiftoffRegister src, LiftoffRegList pinned, ValueKind kind) {
6427 DCHECK(kind == ValueKind::kF32 || kind == ValueKind::kF64);
6432 __ emit_set_if_nan(nondeterminism_addr.gp(), src.fp(), kind);