Lines Matching refs:pinned
67 #define LOAD_INSTANCE_FIELD(dst, name, load_size, pinned) \
68 __ LoadFromInstance(dst, LoadInstanceIntoRegister(pinned, dst), \
73 #define LOAD_TAGGED_PTR_INSTANCE_FIELD(dst, name, pinned) \
76 __ LoadTaggedPointerFromInstance(dst, LoadInstanceIntoRegister(pinned, dst), \
653 LiftoffRegList pinned) {
666 : __ GetUnusedRegister(rc, pinned);
836 LiftoffRegList pinned = kGpParamRegisters;
837 LiftoffRegister tmp = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
844 pinned);
849 LiftoffRegList pinned = kGpParamRegisters;
850 LiftoffRegister tmp = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
852 pinned);
855 __ Load(tmp, tmp.gp(), no_reg, offset, LoadType::kI32Load, pinned);
1113 LiftoffRegList pinned;
1115 pinned.set(max_steps);
1116 LiftoffRegister max_steps_addr = __ GetUnusedRegister(kGpReg, pinned);
1117 pinned.set(max_steps_addr);
1122 pinned);
1130 pinned);
1203 LiftoffRegList pinned;
1205 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
1206 LoadExceptionSymbol(tag_symbol_reg.gp(), pinned, root_index);
1208 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
1209 LOAD_TAGGED_PTR_INSTANCE_FIELD(context_reg.gp(), NativeContext, pinned);
1248 LiftoffRegList pinned;
1249 pinned.set(caught_tag);
1252 Register imm_tag = pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp();
1253 LOAD_TAGGED_PTR_INSTANCE_FIELD(imm_tag, TagsTable, pinned);
1566 LiftoffRegList pinned = {dst};
1568 CheckNan(dst, pinned, result_kind);
1571 CheckS128Nan(dst, pinned, result_lane_kind);
1754 LiftoffRegList pinned;
1755 LiftoffRegister ref = pinned.set(__ PopToRegister());
1756 LiftoffRegister null = __ GetUnusedRegister(kGpReg, pinned);
1757 LoadNullValue(null.gp(), pinned);
1791 LiftoffRegList pinned = {lhs};
1793 ? __ GetUnusedRegister(result_rc, {lhs}, pinned)
1794 : __ GetUnusedRegister(result_rc, pinned);
1822 LiftoffRegList pinned = {dst};
1824 CheckNan(dst, pinned, result_kind);
1827 CheckS128Nan(dst, pinned, result_lane_kind);
2198 LiftoffRegList pinned;
2199 LiftoffRegister obj = pinned.set(__ PopToRegister(pinned));
2200 MaybeEmitNullCheck(decoder, obj.gp(), pinned, arg.type);
2210 LiftoffRegList pinned;
2212 LiftoffRegister info = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
2221 __ LoadToRegister(__ cache_state()->stack_state.back(), pinned);
2223 __ StoreTaggedPointer(info.gp(), no_reg, 0, return_reg, pinned);
2226 StoreType::ForValueKind(return_kind), pinned);
2250 LiftoffRegList pinned;
2251 LiftoffRegister budget = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
2252 LiftoffRegister array = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
2254 pinned);
2258 __ Store(array.gp(), no_reg, offset, budget, StoreType::kI32Store, pinned);
2356 LiftoffRegList* pinned, uint32_t* offset) {
2357 Register addr = pinned->set(__ GetUnusedRegister(kGpReg, {})).gp();
2360 *pinned);
2362 global->index * sizeof(Address), kPointerLoadType, *pinned);
2365 LOAD_INSTANCE_FIELD(addr, GlobalsStart, kSystemPointerSize, *pinned);
2372 const WasmGlobal* global, LiftoffRegList* pinned, Register* base,
2375 pinned->set(__ GetUnusedRegister(kGpReg, *pinned)).gp();
2377 ImportedMutableGlobalsBuffers, *pinned);
2382 *pinned);
2388 pinned->set(__ GetUnusedRegister(kGpReg, *pinned)).gp();
2391 kSystemPointerSize, *pinned);
2396 *pinned);
2412 LiftoffRegList pinned;
2415 GetBaseAndOffsetForImportedMutableExternRefGlobal(global, &pinned,
2417 __ LoadTaggedPointer(base, base, offset, 0, pinned);
2422 LiftoffRegList pinned;
2424 pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp();
2426 pinned);
2427 Register value = pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp();
2431 pinned);
2435 LiftoffRegList pinned;
2437 Register addr = GetGlobalBaseAndOffset(global, &pinned, &offset);
2439 pinned.set(__ GetUnusedRegister(reg_class_for(kind), pinned));
2441 __ Load(value, addr, no_reg, offset, type, pinned, nullptr, false);
2455 LiftoffRegList pinned;
2456 LiftoffRegister value = pinned.set(__ PopToRegister(pinned));
2459 GetBaseAndOffsetForImportedMutableExternRefGlobal(global, &pinned,
2461 __ StoreTaggedPointer(base, offset, 0, value, pinned);
2465 LiftoffRegList pinned;
2467 pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp();
2469 pinned);
2470 LiftoffRegister value = pinned.set(__ PopToRegister(pinned));
2474 value, pinned);
2477 LiftoffRegList pinned;
2479 Register addr = GetGlobalBaseAndOffset(global, &pinned, &offset);
2480 LiftoffRegister reg = pinned.set(__ PopToRegister(pinned));
2487 LiftoffRegList pinned;
2490 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
2511 LiftoffRegList pinned;
2514 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
2554 LiftoffRegList pinned;
2555 LiftoffRegister obj = pinned.set(__ PopToRegister(pinned));
2558 LiftoffRegister null = __ GetUnusedRegister(kGpReg, pinned);
2559 LoadNullValue(null.gp(), pinned);
2570 LiftoffRegList pinned;
2571 Register condition = pinned.set(__ PopToRegister()).gp();
2575 LiftoffRegister false_value = pinned.set(__ PopToRegister(pinned));
2576 LiftoffRegister true_value = __ PopToRegister(pinned);
2712 LiftoffRegList pinned;
2713 LiftoffRegister value = pinned.set(__ PopToRegister());
2718 LiftoffRegister tmp = __ GetUnusedRegister(kGpReg, pinned);
2799 LiftoffRegList pinned, ForceCheck force_check) {
2850 pinned.set(index_ptrsize);
2852 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
2853 LiftoffRegister mem_size = __ GetUnusedRegister(kGpReg, pinned);
2854 LOAD_INSTANCE_FIELD(mem_size.gp(), MemorySize, kSystemPointerSize, pinned);
2879 LiftoffRegList pinned) {
2883 Register address = __ GetUnusedRegister(kGpReg, pinned).gp();
2909 LiftoffRegList pinned;
2910 if (index != no_reg) pinned.set(index);
2913 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
2922 LiftoffRegister info = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
2939 pinned);
2942 StoreType::kI32Store8, pinned);
2945 StoreType::kI32Store8, pinned);
2981 Register GetMemoryStart(LiftoffRegList pinned) {
2984 memory_start = __ GetUnusedRegister(kGpReg, pinned).gp();
2986 pinned);
3012 LiftoffRegList pinned;
3013 Register mem = pinned.set(GetMemoryStart(pinned));
3014 LiftoffRegister value = pinned.set(__ GetUnusedRegister(rc, pinned));
3015 __ Load(value, mem, no_reg, offset, type, pinned, nullptr, true,
3025 LiftoffRegList pinned = {index};
3029 Register mem = pinned.set(GetMemoryStart(pinned));
3030 LiftoffRegister value = pinned.set(__ GetUnusedRegister(rc, pinned));
3033 __ Load(value, mem, index, offset, type, pinned, &protected_load_pc, true,
3069 LiftoffRegList pinned = {index};
3071 Register addr = GetMemoryStart(pinned);
3100 LiftoffRegList pinned;
3101 LiftoffRegister value = pinned.set(__ PopToRegister());
3104 full_index, pinned, kDontForceCheck);
3108 pinned.set(index);
3110 Register addr = GetMemoryStart(pinned);
3135 LiftoffRegList pinned;
3136 LiftoffRegister value = pinned.set(__ PopToRegister());
3145 Register mem = pinned.set(GetMemoryStart(pinned));
3146 __ Store(mem, no_reg, offset, value, type, pinned, nullptr, true);
3148 LiftoffRegister full_index = __ PopToRegister(pinned);
3150 pinned, kDontForceCheck);
3153 pinned.set(index);
3158 Register mem = pinned.set(GetMemoryStart(pinned));
3179 LiftoffRegList pinned;
3180 LiftoffRegister value = pinned.set(__ PopToRegister());
3181 LiftoffRegister full_index = __ PopToRegister(pinned);
3183 full_index, pinned, kDontForceCheck);
3187 pinned.set(index);
3189 Register addr = pinned.set(GetMemoryStart(pinned));
3219 LiftoffRegList pinned;
3220 LiftoffRegister input = pinned.set(__ PopToRegister());
3223 LiftoffRegister result = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
3235 LiftoffRegister high_word = __ GetUnusedRegister(kGpReg, pinned);
3261 if (kNeedI64RegPair) result64 = __ GetUnusedRegister(kGpRegPair, pinned);
3402 LiftoffRegList pinned;
3403 LiftoffRegister ref = pinned.set(__ PopToRegister(pinned));
3404 Register null = __ GetUnusedRegister(kGpReg, pinned).gp();
3405 LoadNullValue(null, pinned);
3408 if (pass_null_along_branch) LoadNullValue(null, pinned);
3424 LiftoffRegList pinned;
3425 LiftoffRegister ref = pinned.set(__ PopToRegister(pinned));
3429 Register null = __ GetUnusedRegister(kGpReg, pinned).gp();
3430 LoadNullValue(null, pinned);
3456 LiftoffRegList pinned = {dst};
3458 CheckNan(dst, pinned, result_kind);
3506 LiftoffRegList pinned = {dst};
3507 CheckS128Nan(dst, pinned, result_lane_kind);
4163 Register value, LiftoffRegList pinned) {
4164 LiftoffRegister tmp_reg = __ GetUnusedRegister(kGpReg, pinned);
4172 tmp_reg, pinned, LiftoffAssembler::kSkipWriteBarrier);
4181 tmp_reg, pinned, LiftoffAssembler::kSkipWriteBarrier);
4185 LiftoffRegister value, LiftoffRegList pinned) {
4188 pinned);
4190 pinned);
4193 pinned);
4196 pinned);
4202 LiftoffRegList pinned) {
4205 wasm::ObjectAccess::ElementOffsetInTaggedFixedArray(*index), pinned);
4210 uint32_t* index, LiftoffRegList pinned) {
4211 LiftoffRegister upper = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
4212 Load16BitExceptionValue(upper, values_array, index, pinned);
4214 Load16BitExceptionValue(LiftoffRegister(dst), values_array, index, pinned);
4220 LiftoffRegList pinned) {
4222 Load32BitExceptionValue(dst.high_gp(), values_array, index, pinned);
4223 Load32BitExceptionValue(dst.low_gp(), values_array, index, pinned);
4225 Load16BitExceptionValue(dst, values_array, index, pinned);
4228 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
4229 Load16BitExceptionValue(tmp_reg, values_array, index, pinned);
4232 Load16BitExceptionValue(tmp_reg, values_array, index, pinned);
4235 Load16BitExceptionValue(tmp_reg, values_array, index, pinned);
4241 int* index_in_array, LiftoffRegList pinned) {
4242 LiftoffRegister value = pinned.set(__ PopToRegister(pinned));
4246 pinned);
4250 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
4253 pinned);
4257 Store64BitExceptionValue(values_array, index_in_array, value, pinned);
4261 pinned.set(__ GetUnusedRegister(reg_class_for(kI64), pinned));
4264 Store64BitExceptionValue(values_array, index_in_array, tmp_reg, pinned);
4269 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
4273 pinned);
4285 value, pinned);
4297 uint32_t* index, LiftoffRegList pinned) {
4299 LiftoffRegister value = pinned.set(__ GetUnusedRegister(rc, pinned));
4302 Load32BitExceptionValue(value.gp(), values_array, index, pinned);
4306 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
4307 Load32BitExceptionValue(tmp_reg.gp(), values_array, index, pinned);
4313 Load64BitExceptionValue(value, values_array, index, pinned);
4318 pinned.set(__ GetUnusedRegister(rc_i64, pinned));
4319 Load64BitExceptionValue(tmp_reg, values_array, index, pinned);
4326 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
4327 Load32BitExceptionValue(tmp_reg.gp(), values_array, index, pinned);
4330 Load32BitExceptionValue(tmp_reg.gp(), values_array, index, pinned);
4341 pinned);
4357 LiftoffRegList pinned;
4361 pinned.set(values_array);
4365 LoadExceptionValue(param.kind(), values_array, &index, pinned);
4404 LiftoffRegList pinned;
4409 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
4423 pinned.set(values_array);
4433 StoreExceptionValue(type, values_array.gp(), &index, pinned);
4440 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
4441 LOAD_TAGGED_PTR_INSTANCE_FIELD(exception_tag.gp(), TagsTable, pinned);
4460 LiftoffRegList pinned;
4461 LiftoffRegister value = pinned.set(__ PopToRegister());
4462 LiftoffRegister full_index = __ PopToRegister(pinned);
4464 full_index, pinned, kDoForceCheck);
4467 pinned.set(index);
4468 AlignmentCheckMem(decoder, type.size(), imm.offset, index, pinned);
4471 Register addr = pinned.set(GetMemoryStart(pinned));
4489 LiftoffRegList pinned = {index};
4490 AlignmentCheckMem(decoder, type.size(), imm.offset, index, pinned);
4493 Register addr = pinned.set(GetMemoryStart(pinned));
4495 LiftoffRegister value = pinned.set(__ GetUnusedRegister(rc, pinned));
4496 __ AtomicLoad(value, addr, index, offset, type, pinned);
4512 LiftoffRegList pinned;
4513 LiftoffRegister value = pinned.set(__ PopToRegister());
4521 result = pinned.set(__ GetUnusedRegister(value.reg_class(), pinned));
4523 pinned.clear(value);
4528 pinned.set(__ GetUnusedRegister(value.reg_class(), pinned));
4530 LiftoffRegister full_index = __ PopToRegister(pinned);
4532 full_index, pinned, kDoForceCheck);
4535 pinned.set(index);
4536 AlignmentCheckMem(decoder, type.size(), imm.offset, index, pinned);
4540 Register addr = pinned.set(GetMemoryStart(pinned));
4558 LiftoffRegList pinned = {index};
4559 AlignmentCheckMem(decoder, type.size(), imm.offset, index, pinned);
4562 Register addr = pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp();
4563 LOAD_INSTANCE_FIELD(addr, MemoryStart, kSystemPointerSize, pinned);
4568 pinned.clear(LiftoffRegister(index));
4569 LiftoffRegister new_value = pinned.set(__ PopToRegister(pinned));
4570 LiftoffRegister expected = pinned.set(__ PopToRegister(pinned));
4586 LiftoffRegList pinned;
4587 LiftoffRegister new_value = pinned.set(__ PopToRegister());
4588 LiftoffRegister expected = pinned.set(__ PopToRegister(pinned));
4589 LiftoffRegister full_index = __ PopToRegister(pinned);
4591 full_index, pinned, kDoForceCheck);
4593 pinned.set(index);
4594 AlignmentCheckMem(decoder, type.size(), imm.offset, index, pinned);
4597 Register addr = pinned.set(GetMemoryStart(pinned));
4599 pinned.set(__ GetUnusedRegister(reg_class_for(result_kind), pinned));
4638 LiftoffRegList pinned = {index_reg};
4640 pinned);
4645 ? pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp()
4685 LiftoffRegList pinned = {index_reg};
4686 AlignmentCheckMem(decoder, kInt32Size, imm.offset, index_reg, pinned);
4691 ? pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp()
4847 LiftoffRegList* pinned) {
4848 LiftoffRegister reg = __ PopToRegister(*pinned);
4853 if (pinned->has(reg) || __ cache_state()->is_used(reg)) {
4854 intptr_reg = __ GetUnusedRegister(kGpReg, *pinned);
4860 pinned->set(intptr_reg);
4868 pinned->set(reg.low());
4871 // be one of the pinned registers, and it cannot be used in the value
4874 pinned->has(reg.high())
4875 ? __ GetUnusedRegister(kGpReg, *pinned).gp()
4876 : __ GetUnusedRegister(kGpReg, {reg.high()}, *pinned).gp();
4877 pinned->set(*high_word);
4892 LiftoffRegList pinned;
4893 LiftoffRegister size = pinned.set(__ PopToRegister());
4894 LiftoffRegister src = pinned.set(__ PopToRegister(pinned));
4896 PopMemTypeToRegister(decoder, &mem_offsets_high_word, &pinned);
4900 instance = __ GetUnusedRegister(kGpReg, pinned).gp();
4903 pinned.set(instance);
4912 pinned.clear(mem_offsets_high_word);
4916 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
4932 LiftoffRegList pinned;
4935 pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp();
4937 pinned);
4940 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
4946 LiftoffRegister null_reg = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
4949 pinned);
4956 LiftoffRegList pinned;
4957 LiftoffRegister size = pinned.set(
4958 PopMemTypeToRegister(decoder, &mem_offsets_high_word, &pinned));
4959 LiftoffRegister src = pinned.set(
4960 PopMemTypeToRegister(decoder, &mem_offsets_high_word, &pinned));
4961 LiftoffRegister dst = pinned.set(
4962 PopMemTypeToRegister(decoder, &mem_offsets_high_word, &pinned));
4966 instance = __ GetUnusedRegister(kGpReg, pinned).gp();
4994 LiftoffRegList pinned;
4995 LiftoffRegister size = pinned.set(
4996 PopMemTypeToRegister(decoder, &mem_offsets_high_word, &pinned));
4997 LiftoffRegister value = pinned.set(__ PopToRegister(pinned));
4998 LiftoffRegister dst = pinned.set(
4999 PopMemTypeToRegister(decoder, &mem_offsets_high_word, &pinned));
5003 instance = __ GetUnusedRegister(kGpReg, pinned).gp();
5035 LiftoffRegList pinned;
5037 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5043 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5064 LiftoffRegList pinned;
5066 pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp();
5068 kSystemPointerSize, pinned);
5071 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5076 LiftoffRegister one_reg = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5079 StoreType::kI32Store8, pinned);
5084 LiftoffRegList pinned;
5087 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5093 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5115 LiftoffRegList pinned;
5118 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5142 LiftoffRegList pinned;
5144 Register tables = pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp();
5145 LOAD_TAGGED_PTR_INSTANCE_FIELD(tables, Tables, pinned);
5150 ObjectAccess::ElementOffsetInTaggedFixedArray(imm.index), pinned);
5159 pinned);
5167 LiftoffRegList pinned;
5170 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5200 LiftoffRegList pinned = {obj};
5206 ? pinned.set(__ PopToRegister(pinned))
5207 : pinned.set(__ GetUnusedRegister(
5208 reg_class_for(field_kind), pinned));
5211 SetDefaultValue(value, field_kind, pinned);
5213 StoreObjectField(obj.gp(), no_reg, offset, value, pinned, field_kind);
5214 pinned.clear(value);
5243 LiftoffRegList pinned;
5244 LiftoffRegister obj = pinned.set(__ PopToRegister(pinned));
5245 MaybeEmitNullCheck(decoder, obj.gp(), pinned, struct_obj.type);
5247 __ GetUnusedRegister(reg_class_for(field_kind), pinned);
5249 pinned);
5259 LiftoffRegList pinned;
5260 LiftoffRegister value = pinned.set(__ PopToRegister(pinned));
5261 LiftoffRegister obj = pinned.set(__ PopToRegister(pinned));
5262 MaybeEmitNullCheck(decoder, obj.gp(), pinned, struct_obj.type);
5263 StoreObjectField(obj.gp(), no_reg, offset, value, pinned, field_kind);
5303 LiftoffRegList pinned = {obj};
5304 LiftoffRegister length = pinned.set(__ PopToModifiableRegister(pinned));
5305 LiftoffRegister value = pinned.set(__ PopToRegister(pinned));
5308 LiftoffRegister offset = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5322 StoreObjectField(obj.gp(), offset.gp(), 0, value, pinned, elem_kind);
5351 LiftoffRegList pinned;
5352 LiftoffRegister index = pinned.set(__ PopToModifiableRegister(pinned));
5353 LiftoffRegister array = pinned.set(__ PopToRegister(pinned));
5354 MaybeEmitNullCheck(decoder, array.gp(), pinned, array_obj.type);
5355 BoundsCheckArray(decoder, array, index, pinned);
5363 __ GetUnusedRegister(reg_class_for(elem_kind), pinned);
5366 elem_kind, is_signed, pinned);
5373 LiftoffRegList pinned;
5374 LiftoffRegister value = pinned.set(__ PopToRegister(pinned));
5377 LiftoffRegister index = pinned.set(__ PopToModifiableRegister(pinned));
5378 LiftoffRegister array = pinned.set(__ PopToRegister(pinned));
5379 MaybeEmitNullCheck(decoder, array.gp(), pinned, array_obj.type);
5380 BoundsCheckArray(decoder, array, index, pinned);
5388 value, pinned, elem_kind);
5392 LiftoffRegList pinned;
5393 LiftoffRegister obj = pinned.set(__ PopToRegister(pinned));
5394 MaybeEmitNullCheck(decoder, obj.gp(), pinned, array_obj.type);
5395 LiftoffRegister len = __ GetUnusedRegister(kGpReg, pinned);
5397 LoadObjectField(len, obj.gp(), no_reg, kLengthOffset, kI32, false, pinned);
5428 LiftoffRegList pinned;
5430 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5436 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5456 LiftoffRegList pinned = {array};
5457 LiftoffRegister element = pinned.set(__ PopToRegister(pinned));
5459 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5464 element, pinned, elem_kind);
5476 LiftoffRegList pinned;
5478 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5569 LiftoffRegList pinned = {},
5572 LiftoffRegister rtt_reg = pinned.set(__ PopToRegister(pinned));
5573 LiftoffRegister obj_reg = pinned.set(__ PopToRegister(pinned));
5580 : pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5581 LiftoffRegister tmp2 = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
5583 LoadNullValue(tmp1.gp(), pinned);
5600 __ LoadTaggedPointer(tmp1.gp(), tmp1.gp(), no_reg, kTypeInfoOffset, pinned);
5605 pinned);
5611 __ LoadFixedArrayLengthAsInt32(list_length, tmp1.gp(), pinned);
5618 wasm::ObjectAccess::ElementOffsetInTaggedFixedArray(rtt_depth), pinned);
5630 LiftoffRegList pinned;
5631 LiftoffRegister result = pinned.set(__ GetUnusedRegister(kGpReg, {}));
5633 SubtypeCheck(decoder, obj, rtt, &return_false, kNullFails, pinned,
5706 LiftoffRegList pinned, Register opt_scratch) {
5708 TypeCheckPrelude(obj, no_match, pinned, opt_scratch);
5710 pinned);
5715 LiftoffRegList pinned, Register opt_scratch) {
5717 TypeCheckPrelude(obj, no_match, pinned, opt_scratch);
5720 LoadType::kI32Load16U, pinned);
5727 LiftoffRegList pinned, Register opt_scratch) {
5729 TypeCheckPrelude(obj, no_match, pinned, opt_scratch);
5732 LoadType::kI32Load16U, pinned);
5739 LiftoffRegList pinned, Register opt_scratch) {
5740 LiftoffRegister obj_reg = pinned.set(__ PopToRegister(pinned));
5748 const Value& obj, Label* no_match, LiftoffRegList pinned,
5754 LiftoffRegList pinned;
5755 LiftoffRegister result = pinned.set(__ GetUnusedRegister(kGpReg, {}));
5757 (this->*type_checker)(object, &no_match, pinned, result.gp());
5942 LiftoffRegList pinned;
5943 Register tmp = pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp();
5944 Register target = pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp();
5948 kSystemPointerSize, pinned);
5950 imm.index * sizeof(Address), kPointerLoadType, pinned);
5954 ImportedFunctionRefs, pinned);
5958 ObjectAccess::ElementOffsetInTaggedFixedArray(imm.index), pinned);
6015 LiftoffRegList pinned = {index};
6017 Register table = pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp();
6018 Register tmp_const = pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp();
6019 Register scratch = pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp();
6023 pinned.set(__ GetUnusedRegister(kGpReg, pinned)).gp();
6025 IndirectFunctionTables, pinned);
6031 pinned);
6047 pinned);
6052 LoadType::kI32Load, pinned);
6061 kSystemPointerSize, pinned);
6066 kPointerLoadType, pinned);
6072 pinned);
6093 LOAD_TAGGED_PTR_INSTANCE_FIELD(table, IndirectFunctionTableRefs, pinned);
6098 pinned);
6102 pinned);
6116 kSystemPointerSize, pinned);
6121 kPointerLoadType, pinned);
6124 pinned);
6164 LiftoffRegList pinned;
6165 LiftoffRegister vector = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
6168 if (funcref.is_reg()) pinned.set(funcref.reg());
6171 LiftoffRegister index = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
6206 LiftoffRegList pinned;
6207 LiftoffRegister func_ref = pinned.set(__ PopToModifiableRegister(pinned));
6208 MaybeEmitNullCheck(decoder, func_ref.gp(), pinned, func_ref_type);
6210 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
6211 LiftoffRegister target = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
6212 LiftoffRegister temp = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
6218 pinned);
6221 LOAD_INSTANCE_FIELD(temp.gp(), IsolateRoot, kSystemPointerSize, pinned);
6229 kPointerLoadType, pinned);
6242 pinned);
6274 void LoadNullValue(Register null, LiftoffRegList pinned) {
6275 LOAD_INSTANCE_FIELD(null, IsolateRoot, kSystemPointerSize, pinned);
6280 void LoadExceptionSymbol(Register dst, LiftoffRegList pinned,
6282 LOAD_INSTANCE_FIELD(dst, IsolateRoot, kSystemPointerSize, pinned);
6288 LiftoffRegList pinned, ValueType type) {
6292 LiftoffRegister null = __ GetUnusedRegister(kGpReg, pinned);
6293 LoadNullValue(null.gp(), pinned);
6299 LiftoffRegister index, LiftoffRegList pinned) {
6303 LiftoffRegister length = __ GetUnusedRegister(kGpReg, pinned);
6307 pinned);
6319 LiftoffRegList pinned) {
6321 __ LoadTaggedPointer(dst.gp(), src, offset_reg, offset, pinned);
6325 __ Load(dst, src, offset_reg, offset, load_type, pinned);
6330 LiftoffRegister value, LiftoffRegList pinned,
6333 __ StoreTaggedPointer(obj, offset_reg, offset, value, pinned);
6337 __ Store(obj, offset_reg, offset, value, store_type, pinned);
6342 LiftoffRegList pinned) {
6359 return LoadNullValue(reg.gp(), pinned);
6373 LiftoffRegList pinned,
6375 LiftoffRegister obj_reg = pinned.set(__ PopToRegister(pinned));
6382 : pinned.set(__ GetUnusedRegister(kGpReg, pinned));
6383 LiftoffRegister tmp_reg = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
6386 LoadNullValue(map_reg.gp(), pinned);
6398 LiftoffRegList pinned) {
6402 pinned);
6426 void CheckNan(LiftoffRegister src, LiftoffRegList pinned, ValueKind kind) {
6428 auto nondeterminism_addr = __ GetUnusedRegister(kGpReg, pinned);
6435 void CheckS128Nan(LiftoffRegister dst, LiftoffRegList pinned,
6438 LiftoffRegister tmp_gp = pinned.set(__ GetUnusedRegister(kGpReg, pinned));
6439 LiftoffRegister tmp_s128 = pinned.set(__ GetUnusedRegister(rc, pinned));
6441 pinned.set(__ GetUnusedRegister(kGpReg, pinned));
6485 Register LoadInstanceIntoRegister(LiftoffRegList pinned, Register fallback) {
6489 pinned | LiftoffRegList{fallback});