Lines Matching refs:CAST
151 CAST(LoadFeedbackVectorSlot(feedback_vector, slot_id, kTaggedSize));
1124 return CAST(CallCFunction(smi_lexicographic_compare, MachineType::AnyTagged(),
1197 Branch(IsJSReceiver(CAST(object)), if_true, if_false);
1490 BranchIfSmiEqual(CAST(value), SmiConstant(0), if_false, if_true);
1495 TNode<HeapObject> value_heapobject = CAST(value);
1525 TNode<BigInt> bigint = CAST(value);
1799 [=] { return CAST(properties); });
1814 TNode<HeapObject> dict = CAST(properties);
1845 return CAST(length);
1954 InstanceTypeEqual(LoadInstanceType(CAST(result.value())), MAP_TYPE);
1957 LoadObjectField(CAST(result.value()),
1971 TNode<HeapObject> object = CAST(LoadObjectField(
2002 TNode<HeapObject> properties = CAST(properties_or_hash);
2023 var_hash = SmiUntag(CAST(properties_or_hash));
2038 ChangeUint32ToWord(LoadSwissNameDictionaryHash(CAST(properties))));
2045 var_hash = SmiUntag(CAST(LoadFixedArrayElement(
2046 CAST(properties), NameDictionary::kObjectHashIndex)));
2109 *extracted = CAST(maybe_object);
2113 *extracted = CAST(maybe_object);
2134 return CAST(value);
2276 return CAST(element);
2324 return CAST(LoadArrayElement(object, PropertyArray::kHeaderSize, index,
2725 var_result = LoadFixedArrayElement(CAST(elements), index, 0);
2731 var_result = LoadFixedArrayElement(CAST(elements), index);
2738 LoadFixedDoubleArrayElement(CAST(elements), index));
2745 LoadFixedDoubleArrayElement(CAST(elements), index, if_hole));
2752 var_result = BasicLoadNumberDictionaryElement(CAST(elements), index,
2790 return CAST(LoadContextElement(context, Context::SCOPE_INFO_INDEX));
2810 return CAST(LoadObjectField(
2816 TNode<Map> module_map = CAST(
2830 GotoIf(TaggedEqual(LoadMap(CAST(cur_context.value())), module_map),
2834 LoadContextElement(CAST(cur_context.value()), Context::PREVIOUS_INDEX);
2845 CAST(LoadContextElement(module_context, Context::EXTENSION_INDEX));
2864 CAST(LoadContextElement(native_context, Context::OBJECT_FUNCTION_INDEX));
2865 return CAST(LoadJSFunctionPrototypeOrInitialMap(object_function));
2870 TNode<Map> map = CAST(LoadContextElement(
2951 var_result = LoadMapPrototype(CAST(proto_or_map));
2971 TNode<CodeT> code = CAST(var_result.value());
2994 return CAST(var_result.value());
3071 StoreMapNoWriteBarrier(object, CAST(LoadRoot(map_root_index)));
3084 StoreMap(object, CAST(root));
3309 StoreElement(elements, kind, index, ChangeNumberToFloat64(CAST(value)));
3342 TNode<Cell> cell = CAST(result);
3487 return CAST(result);
3540 return CAST(var_result.value());
3556 return CAST(result);
3562 [=] { return IsContext(CAST(object)); });
3578 return CAST(result);
3595 return CAST(result);
3731 TNode<CollectionType> table = CAST(AllocateFixedArray(
3854 return CAST(object);
4095 FillFixedDoubleArrayWithZero(CAST(elements.value()), capacity);
4097 FillFixedArrayWithSmiZero(CAST(elements.value()), capacity);
4157 return CAST(array);
4237 base::Optional<TNode<BInt>>(TaggedToParameter<BInt>(CAST(length))),
4257 base::Optional<TNode<BInt>>(TaggedToParameter<BInt>(CAST(length))),
4287 CAST(length), allocation_site);
4673 TNode<PropertyArray> property_array = CAST(array);
4709 float_value = LoadHeapNumberValue(CAST(value));
5213 value = CloneIfMutablePrimitive(CAST(value));
5229 FillPropertyArrayWithUndefined(CAST(from_array), start, property_count);
5280 return SmiToFloat64(CAST(value));
5282 return LoadHeapNumberValue(CAST(value));
5419 acc_intptr = SmiUntag(CAST(acc));
5423 GotoIfNot(IsHeapNumber(CAST(acc)), if_not_possible);
5424 TNode<Float64T> value = LoadHeapNumberValue(CAST(acc));
5438 TaggedIsSmi(value), [&]() { return SmiToFloat64(CAST(value)); },
5440 GotoIfNot(IsHeapNumber(CAST(value)), if_valueisnotnumber);
5441 return LoadHeapNumberValue(CAST(value));
5536 *var_word32 = SmiToInt32(CAST(value));
5548 TNode<HeapObject> value_heap_object = CAST(value);
5582 *var_word32 = TruncateHeapNumberValueToWord32(CAST(value));
5588 *var_maybe_bigint = CAST(value);
5598 *var_word32 = SmiToInt32(CAST(value));
5608 var_result = SmiToInt32(CAST(number));
5612 TNode<Float64T> value = LoadHeapNumberValue(CAST(number));
5843 TNode<Uint16T> value_instance_type = LoadInstanceType(CAST(value));
5873 return CAST(var_value.value());
5882 var_result = Unsigned(SmiToInt32(CAST(value)));
5887 var_result = ChangeFloat64ToUint32(LoadHeapNumberValue(CAST(value)));
5899 result = LoadHeapNumberValue(CAST(value));
5904 result = SmiToFloat64(CAST(value));
5921 CAST(CallBuiltin(Builtin::kNonNumberToNumber, context, input)));
5931 var_result = SmiToFloat64(CAST(input));
5936 IsHeapNumber(CAST(input)),
5937 [=] { return LoadHeapNumberValue(CAST(input)); },
5940 CAST(CallBuiltin(Builtin::kNonNumberToNumber, context, input)));
5976 TNode<HeapObject> value = CAST(var_value.value());
6053 TNode<Map> map = LoadMap(CAST(value));
6076 TNode<Map> value_map = LoadMap(CAST(value));
6095 Branch(IsCallable(CAST(value)), &out, &throw_exception);
6583 TNode<HeapObject> heap_object = CAST(object);
6747 LoadNameRawHashField(CAST(object)),
6765 return IsSetWord32(LoadNameRawHashField(CAST(object)),
6883 Word32Or(IsHeapNumber(CAST(object)), IsBigInt(CAST(object))));
6893 TNode<Float64T> value = LoadHeapNumberValue(CAST(number));
6913 [=] { return IsHeapNumberPositive(CAST(number)); });
6929 TNode<HeapNumber> heap_number = CAST(number);
6942 IsHeapNumber(CAST(number)),
6971 IsHeapNumber(CAST(number)),
7000 [=] { return IsHeapNumberUint32(CAST(number)); });
7061 var_result = UncheckedCast<Uint16T>(SmiToInt32(CAST(result)));
7105 var_result = CAST(entry);
7250 TNode<RawPtrT> result = LoadExternalStringResourceDataPtr(CAST(string));
7281 CAST(CallRuntime(Runtime::kStringToNumber, NoContextConstant(), input));
7307 smi_input = CAST(input);
7313 TNode<HeapNumber> heap_number_input = CAST(input);
7330 TNode<HeapObject> number_key_heap_object = CAST(number_key);
7342 result = CAST(UnsafeLoadFixedArrayElement(number_string_cache, entry_index,
7360 result = CAST(UnsafeLoadFixedArrayElement(number_string_cache, entry_index,
7407 result = CAST(
7450 var_result = CAST(result);
7458 var_input = CAST(result);
7486 var_result = CAST(var_input.value());
7494 var_result = CAST(CallRuntime(Runtime::kBigIntToNumber, context,
7511 var_result = CAST(CallRuntime(function_id, context, var_input.value()));
7527 return CAST(NonNumberToNumberOrNumeric(
7549 *var_result = StringToNumber(CAST(input));
7565 return CAST(ToNumberOrNumeric([context] { return context; }, input, nullptr,
7576 var_result = CAST(input);
7582 IsHeapNumber(CAST(input)), [=] { return CAST(input); },
7584 return CAST(CallBuiltin(Builtin::kNonNumberToNumber, context, input));
7602 TNode<Smi> input_smi = CAST(input);
7612 TNode<HeapObject> input_ho = CAST(input);
7615 TNode<HeapNumber> input_hn = CAST(input_ho);
7629 var_result = CAST(input_ho);
7654 TNode<Smi> input_smi = CAST(input);
7661 TNode<HeapObject> input_ho = CAST(input);
7664 TNode<HeapNumber> input_hn = CAST(input_ho);
7687 GotoIf(IsBigInt(CAST(input)), &if_bigint);
7688 var_result = CAST(CallRuntime(Runtime::kToBigInt, context, input));
7692 var_result = CAST(input);
7722 TNode<HeapObject> heap_object_value = CAST(value);
7730 *var_numeric = CAST(
7736 *var_numeric = CAST(value);
7741 *var_numeric = CAST(value);
7746 *var_numeric = CAST(value);
7753 CAST(LoadObjectField(heap_object_value, Oddball::kToNumberOffset));
7794 const TNode<Int32T> uint32_value = SmiToInt32(CAST(number));
7803 const TNode<Float64T> value = LoadHeapNumberValue(CAST(number));
7860 return CAST(var_result.value());
7869 Branch(IsString(CAST(input)), &out, &stub_call);
7876 return CAST(var_result.value());
7881 return CAST(CallBuiltin(Builtin::kToObject, context, input));
7894 result = CAST(input);
7912 TaggedIsSmi(input), [=] { return SmiMax(CAST(input), smi_zero); },
7913 [=] { return CAST(CallBuiltin(Builtin::kToLength, context, input)); });
8068 *var_unique = CAST(key);
8076 TNode<Uint32T> raw_hash_field = LoadNameRawHashField(CAST(key));
8096 *var_unique = CAST(key);
8102 LoadObjectField<String>(CAST(key), ThinString::kActualOffset);
8121 LoadObjectField<String>(CAST(key), Oddball::kToStringOffset);
8199 CAST(CallCFunction(function, MachineType::AnyTagged(),
8204 TNode<IntPtrT> word_result = SmiUntag(CAST(result));
8213 *var_internalized = CAST(result);
8236 return CAST(LoadDescriptorArrayElement<HeapObject>(container, key_index, 0));
8271 return CAST(LoadDescriptorArrayElement<HeapObject>(
8278 return CAST(LoadDescriptorArrayElement<HeapObject>(
8496 TNode<PropertyCell> property_cell = CAST(key);
8497 return CAST(LoadObjectField(property_cell, PropertyCell::kNameOffset));
8517 CAST(LoadValueByKeyIndex<NameToIndexHashTable>(table, var_entry.value()));
8559 CAST(UnsafeLoadFixedArrayElement(dictionary, index));
8654 TNode<IntPtrT> current_value = SmiUntag(CAST(current));
8661 TNode<Float64T> current_value = LoadHeapNumberValue(CAST(current));
8837 return CAST(
8881 TNode<Name> candidate_name = CAST(element);
8952 return CAST(element);
9148 TNode<DescriptorArray> descriptors = CAST(var_meta_storage.value());
9165 CAST(var_meta_storage.value());
9238 var_maybe_constructor = CAST(
9259 TNode<Map> function_map = LoadMap(CAST(constructor));
9266 var_function = CAST(receiver);
9271 var_function = CAST(constructor);
9277 var_function = LoadJSGeneratorObjectFunction(CAST(receiver));
9312 TNode<JSProxy> proxy = CAST(current.value());
9314 CAST(LoadObjectField(proxy, JSProxy::kHandlerOffset));
9318 CAST(LoadObjectField(proxy, JSProxy::kTargetOffset));
9328 TNode<JSBoundFunction> bound_function = CAST(current.value());
9329 TNode<JSReceiver> target = CAST(LoadObjectField(
9337 TNode<JSWrappedFunction> wrapped_function = CAST(current.value());
9338 TNode<JSReceiver> target = CAST(LoadObjectField(
9346 TNode<JSFunction> function = CAST(current.value());
9348 CAST(LoadObjectField(function, JSFunction::kContextOffset));
9429 TNode<PropertyDictionary> dictionary = CAST(LoadSlowProperties(object));
9446 TryLookupPropertyInSimpleObject(CAST(object), map, unique_name, if_found_fast,
9462 TNode<GlobalDictionary> dictionary = CAST(LoadSlowProperties(CAST(object)));
9491 LoadPropertyFromGlobalDictionary(CAST(var_meta_storage.value()),
9524 GotoIfNot(IsJSReceiver(CAST(sync_iterator)), ¬_receiver);
9530 const TNode<Map> map = CAST(LoadContextElement(
9614 CAST(LoadObjectField(object, field_offset));
9622 TNode<HeapObject> properties = LoadFastProperties(CAST(object));
9625 LoadPropertyArrayElement(CAST(properties), field_index);
9638 var_double_value = LoadHeapNumberValue(CAST(value));
9678 CAST(LoadFixedArrayElement(dictionary, name_index));
9718 GotoIfNot(IsAccessorPair(CAST(value)), &if_accessor_info);
9725 TNode<AccessorPair> accessor_pair = CAST(value);
9727 CAST(LoadObjectField(accessor_pair, AccessorPair::kGetterOffset));
9759 GetCreationContext(CAST(holder), if_bailout);
9790 TNode<AccessorInfo> accessor_info = CAST(value);
9808 TNode<JSArray> array = CAST(holder);
9821 TNode<JSFunction> function = CAST(holder);
9835 TNode<Object> holder_value = LoadJSPrimitiveWrapperValue(CAST(holder));
9837 GotoIfNot(IsString(CAST(holder_value)), if_bailout);
9838 var_value = LoadStringLengthAsSmi(CAST(holder_value));
9882 TNode<DescriptorArray> descriptors = CAST(var_meta_storage.value());
9891 TNode<PropertyDictionary> dictionary = CAST(var_meta_storage.value());
9899 TNode<GlobalDictionary> dictionary = CAST(var_meta_storage.value());
10014 TNode<FixedArray> elements = CAST(LoadElements(CAST(object)));
10025 TNode<FixedArrayBase> elements = LoadElements(CAST(object));
10031 LoadFixedDoubleArrayElement(CAST(elements), intptr_index, if_not_found,
10047 TNode<NumberDictionary> elements = CAST(LoadElements(CAST(object)));
10053 TNode<String> string = CAST(LoadJSPrimitiveWrapperValue(CAST(object)));
10060 TNode<String> string = CAST(LoadJSPrimitiveWrapperValue(CAST(object)));
10067 TNode<JSArrayBuffer> buffer = LoadJSArrayBufferViewBuffer(CAST(object));
10070 TNode<UintPtrT> length = LoadJSTypedArrayLength(CAST(object));
10075 TNode<JSArrayBuffer> buffer = LoadJSArrayBufferViewBuffer(CAST(object));
10077 LoadVariableLengthJSTypedArrayLength(CAST(object), buffer, if_absent);
10131 TNode<HeapObject> object = CAST(object_arg);
10165 lookup_property_in_holder(CAST(receiver), var_holder.value(), holder_map,
10175 BranchIfMaybeSpecialIndex(CAST(var_unique.value()), if_bailout,
10183 GotoIf(IsPrivateSymbol(CAST(key)), if_end);
10210 lookup_element_in_holder(CAST(receiver), var_holder.value(),
10286 var_result = CAST(
10311 TNode<HeapObject> object = CAST(object_maybe_smi);
10312 TNode<HeapObject> callable = CAST(callable_maybe_smi);
10320 GotoIfPrototypeRequiresRuntimeLookup(CAST(callable), callable_map,
10354 var_result = CAST(CallRuntime(Runtime::kOrdinaryHasInstance, context,
10477 TNode<FeedbackVector> vector = CAST(feedback_cell_array.value());
10478 feedback_cell_array = CAST(
10483 return CAST(feedback_cell_array.value());
10488 CAST(LoadFromParentFrame(StandardFrameConstants::kFunctionOffset));
10489 return CAST(LoadFeedbackVector(function));
10493 return CAST(
10498 return CAST(LoadFromParentFrame(InterpreterFrameConstants::kContextOffset));
10505 TNode<JSFunction> function = CAST(
10508 return CAST(LoadFeedbackVector(function));
10521 UpdateFeedback(feedback, CAST(maybe_feedback_vector), slot_id);
10532 UpdateFeedback(feedback, CAST(maybe_vector), slot_id);
10548 TNode<Smi> previous_feedback = CAST(feedback_element);
10622 TNode<Int32T> instance_type = LoadInstanceType(CAST(key));
10632 var_intptr_key = SmiUntag(CAST(key));
10638 TNode<Float64T> value = LoadHeapNumberValue(CAST(key));
10665 TNode<ScriptContextTable> script_context_table = CAST(
10668 TNode<Context> script_context = CAST(LoadFixedArrayElement(
10825 TNode<Smi> smi_value = CAST(value);
10826 StoreFixedArrayElement(CAST(elements), index, smi_value);
10828 StoreFixedArrayElement(CAST(elements), index, value);
10840 StoreFixedDoubleArrayElement(CAST(elements), index, value);
10938 TNode<HeapObject> heap_object = CAST(var_input.value());
10959 TNode<Int32T> value = SmiToInt32(CAST(var_input.value()));
10994 TNode<HeapObject> heap_object = CAST(var_input.value());
11011 TNode<Int32T> value = SmiToInt32(CAST(var_input.value()));
11042 TNode<HeapObject> heap_object = CAST(var_input.value());
11058 TNode<Int32T> value = SmiToInt32(CAST(var_input.value()));
11146 GotoIf(IsHeapNumber(CAST(value)), &dont_allocate_heap_number);
11166 GotoIf(IsHeapNumber(CAST(value)), &dont_allocate_heap_number);
11280 TNode<JSTypedArray> typed_array = CAST(object);
11343 return CAST(LoadJSArrayLength(CAST(object)));
11361 LoadFixedArrayElement(CAST(elements), intptr_key);
11424 TNode<FixedArrayBase> new_elements = CAST(maybe_elements);
11493 return SmiUntag(LoadFastJSArrayLength(CAST(object)));
11629 return CAST(site);
11648 TNode<Smi> transition_info = CAST(LoadObjectField(
11655 TNode<JSObject> boilerplate = CAST(LoadObjectField(
11822 TNode<Smi> smi_left = CAST(left);
11827 TNode<Smi> smi_right = CAST(right);
11855 var_right_float = LoadHeapNumberValue(CAST(right));
11860 var_left_float = LoadHeapNumberValue(CAST(left));
11865 var_right_float = SmiToFloat64(CAST(right));
11869 var_right_float = LoadHeapNumberValue(CAST(right));
11961 cur_context = CAST(
12004 TNode<Smi> smi_left = CAST(left);
12009 TNode<Map> right_map = LoadMap(CAST(right));
12017 TNode<Smi> smi_right = CAST(right);
12046 var_right_float = LoadHeapNumberValue(CAST(right));
12053 var_result = CAST(CallRuntime(Runtime::kBigIntCompareToNumber,
12073 TNode<Map> left_map = LoadMap(CAST(left));
12090 var_left_float = LoadHeapNumberValue(CAST(left));
12091 var_right_float = SmiToFloat64(CAST(right));
12098 var_result = CAST(CallRuntime(Runtime::kBigIntCompareToNumber,
12118 TNode<Map> right_map = LoadMap(CAST(right));
12143 var_left_float = LoadHeapNumberValue(CAST(left));
12144 var_right_float = LoadHeapNumberValue(CAST(right));
12152 var_result = CAST(CallRuntime(
12186 var_result = CAST(CallRuntime(Runtime::kBigIntCompareToNumber,
12196 var_result = CAST(CallRuntime(Runtime::kBigIntCompareToBigInt,
12206 var_result = CAST(CallRuntime(Runtime::kBigIntCompareToString,
12254 var_result = CAST(CallBuiltin(builtin, context(), left, right));
12279 var_result = CAST(CallRuntime(
12417 TNode<HeapObject> value_heapobject = CAST(value);
12563 TNode<Map> right_map = LoadMap(CAST(right));
12581 var_left_float = SmiToFloat64(CAST(left));
12582 var_right_float = LoadHeapNumberValue(CAST(right));
12598 var_right = LoadObjectField(CAST(right), Oddball::kToNumberOffset);
12606 result = CAST(CallRuntime(Runtime::kBigIntEqualToNumber,
12631 TNode<Map> left_map = LoadMap(CAST(left));
12632 TNode<Map> right_map = LoadMap(CAST(right));
12647 CAST(CallBuiltin(Builtin::kStringEqual, context(), left, right));
12661 var_left_float = LoadHeapNumberValue(CAST(left));
12662 var_right_float = LoadHeapNumberValue(CAST(right));
12689 LoadObjectField(CAST(right), Oddball::kToNumberOffset);
12712 result = CAST(CallRuntime(Runtime::kBigIntEqualToNumber,
12720 result = CAST(CallRuntime(Runtime::kBigIntEqualToBigInt,
12728 result = CAST(CallRuntime(Runtime::kBigIntEqualToString,
12737 var_right = LoadObjectField(CAST(right), Oddball::kToNumberOffset);
12813 var_left = LoadObjectField(CAST(left), Oddball::kToNumberOffset);
12902 TNode<Map> right_map = LoadMap(CAST(right));
13021 TNode<Map> lhs_map = LoadMap(CAST(lhs));
13036 TNode<Float64T> lhs_value = LoadHeapNumberValue(CAST(lhs));
13037 TNode<Float64T> rhs_value = SmiToFloat64(CAST(rhs));
13047 TNode<HeapObject> rhs_ho = CAST(rhs);
13058 TNode<Float64T> lhs_value = LoadHeapNumberValue(CAST(lhs));
13059 TNode<Float64T> rhs_value = LoadHeapNumberValue(CAST(rhs));
13095 TNode<Uint16T> rhs_instance_type = LoadInstanceType(CAST(rhs));
13112 result = CAST(CallBuiltin(Builtin::kStringEqual,
13131 TNode<Uint16T> rhs_instance_type = LoadInstanceType(CAST(rhs));
13143 result = CAST(CallRuntime(Runtime::kBigIntEqualToBigInt,
13155 TNode<Map> rhs_map = LoadMap(CAST(rhs));
13261 TNode<Map> rhs_map = LoadMap(CAST(rhs));
13270 TNode<Float64T> lhs_value = SmiToFloat64(CAST(lhs));
13271 TNode<Float64T> rhs_value = LoadHeapNumberValue(CAST(rhs));
13337 GotoIfNot(IsHeapNumber(CAST(rhs)), if_false);
13338 var_lhs_value = SmiToFloat64(CAST(lhs));
13339 var_rhs_value = LoadHeapNumberValue(CAST(rhs));
13352 GotoIfNot(IsHeapNumber(CAST(lhs)), if_false);
13353 var_lhs_value = LoadHeapNumberValue(CAST(lhs));
13354 var_rhs_value = SmiToFloat64(CAST(rhs));
13364 const TNode<Map> lhs_map = LoadMap(CAST(lhs));
13376 GotoIfNot(IsHeapNumber(CAST(rhs)), if_false);
13377 var_lhs_value = LoadHeapNumberValue(CAST(lhs));
13378 var_rhs_value = LoadHeapNumberValue(CAST(rhs));
13387 GotoIfNot(IsString(CAST(rhs)), if_false);
13395 GotoIfNot(IsBigInt(CAST(rhs)), if_false);
13474 TNode<Name> name = CAST(CallBuiltin(Builtin::kToName, context, key));
13479 result = CAST(
13514 CAST(CallRuntime(fallback_runtime_function_id, context, object, key));
13538 TNode<Map> map_enumerator = CAST(enumerator);
13567 TNode<FixedArray> array_enumerator = CAST(enumerator);
13592 TNode<HeapObject> value_heap_object = CAST(value);
13632 CAST(LoadObjectField(value_heap_object, Oddball::kTypeOfOffset));
13705 GotoIfNot(IsConstructorMap(LoadMap(CAST(species))), &throw_error);
13706 var_result = CAST(species);
13728 GotoIfNot(IsJSReceiver(CAST(callable)), &if_notreceiver);
13747 CAST(CallJS(builtin, context, inst_of_handler, callable, object));
13767 GotoIfNot(IsCallable(CAST(callable)), &if_notcallable);
13770 var_result = CAST(
13802 TNode<Smi> smi_value = CAST(value);
13816 TNode<HeapNumber> heap_number_value = CAST(value);
13844 TNode<Smi> smi_value = CAST(value);
13859 TNode<HeapNumber> heap_number_value = CAST(value);
13886 var_result = TrySmiAdd(CAST(a), CAST(b), &float_add);
13907 var_result = TrySmiSub(CAST(a), CAST(b), &float_sub);
13925 Branch(IsHeapNumber(CAST(input)), &is_number, is_not_number);
13931 GotoIf(IsHeapNumber(CAST(input)), is_number);
13999 TNode<Map> map = CAST(
14009 return CAST(result);
14024 TNode<Map> array_map = CAST(LoadContextElement(
14032 TNode<Map> iterator_map = CAST(
14043 return CAST(result);
14050 CAST(CallRuntime(Runtime::kArraySpeciesConstructor, context, o));
14368 return CAST(var_result.value());
14629 return CAST(BitcastWordToTagged(Load<RawPtrT>(table, offset)));
14649 GotoIf(SmiEqual(CAST(sfi_data), SmiConstant(Builtin::kCompileLazy)),
14652 sfi_code = LoadBuiltin(CAST(sfi_data));
14657 TNode<Uint16T> data_type = LoadInstanceType(CAST(sfi_data));
14714 TNode<CodeT> baseline_code = CAST(sfi_data);
14737 LoadInterpreterDataInterpreterTrampoline(CAST(sfi_data));
14745 sfi_code = CAST(LoadObjectField(
14746 CAST(sfi_data), WasmExportedFunctionData::kWrapperCodeOffset));
14800 return CAST(fun);
14829 TNode<Number> object_length = LoadJSArrayLength(CAST(var_object.value()));
14839 var_object = CAST(object);
15032 CAST(LoadContextElement(native_context, Context::ARRAY_FUNCTION_INDEX));
15033 array = CAST(CallRuntimeNewArray(context, array_function, length,
15039 TNode<Smi> length_smi = CAST(length);
15041 TNode<Map> array_map = CAST(LoadContextElement(
15072 return CAST(CallCFunction(refill_math_random, type_tagged,
15079 ToDirectStringAssembler to_direct(state(), CAST(value));
15082 return CAST(value);
15803 return CAST(Load<Object>(dict, offset_minus_tag));
15964 TNode<IntPtrT> page_flags = LoadBasicMemoryChunkFlags(CAST(value));
15972 LoadMapInstanceType(LoadMap(CAST(value)));
16001 WordAnd(LoadBasicMemoryChunkFlags(CAST(var_shared_value->value())),