Lines Matching refs:Handle
101 Handle<ByteArray> reloc_info =
106 Handle<CodeDataContainer> data_container;
115 const auto canonical_code_data_container = Handle<CodeDataContainer>::cast(
141 Handle<OnHeapBasicBlockProfilerData> on_heap_profiler_data;
147 Handle<ArrayList> list(isolate_->heap()->basic_block_profiling_data(),
149 Handle<ArrayList> new_list =
158 Handle<Code> code;
202 Handle<Object> self_reference;
254 Handle<String> disassembly =
292 Handle<Code> code = handle(Code::cast(result), isolate_);
320 Handle<Code> code = handle(Code::cast(result), local_isolate_);
329 Handle<Code> Factory::CodeBuilder::Build() {
340 Handle<Map> map, AllocationType allocation,
341 Handle<AllocationSite> allocation_site) {
373 HeapObject Factory::New(Handle<Map> map, AllocationType allocation) {
386 Handle<HeapObject> Factory::NewFillerObject(int size,
394 return Handle<HeapObject>(result, isolate());
397 Handle<PrototypeInfo> Factory::NewPrototypeInfo() {
408 Handle<EnumCache> Factory::NewEnumCache(Handle<FixedArray> keys,
409 Handle<FixedArray> indices) {
418 Handle<Tuple2> Factory::NewTuple2(Handle<Object> value1, Handle<Object> value2,
427 Handle<Oddball> Factory::NewOddball(Handle<Map> map, const char* to_string,
428 Handle<Object> to_number,
430 Handle<Oddball> oddball(Oddball::cast(New(map, AllocationType::kReadOnly)),
436 Handle<Oddball> Factory::NewSelfReferenceMarker() {
442 Handle<Oddball> Factory::NewBasicBlockCountersMarker() {
449 Handle<PropertyArray> Factory::NewPropertyArray(int length,
484 Handle<ClosureFeedbackCellArray> Factory::NewClosureFeedbackCellArray(
488 Handle<ClosureFeedbackCellArray> feedback_cell_array =
489 Handle<ClosureFeedbackCellArray>::cast(NewFixedArrayWithMap(
496 Handle<FeedbackVector> Factory::NewFeedbackVector(
497 Handle<SharedFunctionInfo> shared,
498 Handle<ClosureFeedbackCellArray> closure_feedback_cell_array) {
520 Handle<EmbedderDataArray> Factory::NewEmbedderDataArray(int length) {
537 Handle<FixedArrayBase> Factory::NewFixedDoubleArrayWithHoles(int length) {
539 Handle<FixedArrayBase> array = NewFixedDoubleArray(length);
541 Handle<FixedDoubleArray>::cast(array)->FillWithHoles(0, length);
547 Handle<T> Factory::AllocateSmallOrderedHashTable(Handle<Map> map, int capacity,
564 Handle<T> table(T::cast(result), isolate());
569 Handle<SmallOrderedHashSet> Factory::NewSmallOrderedHashSet(
575 Handle<SmallOrderedHashMap> Factory::NewSmallOrderedHashMap(
581 Handle<SmallOrderedNameDictionary> Factory::NewSmallOrderedNameDictionary(
583 Handle<SmallOrderedNameDictionary> dict =
590 Handle<OrderedHashSet> Factory::NewOrderedHashSet() {
596 Handle<OrderedHashMap> Factory::NewOrderedHashMap() {
602 Handle<OrderedNameDictionary> Factory::NewOrderedNameDictionary(int capacity) {
608 Handle<NameDictionary> Factory::NewNameDictionary(int at_least_space_for) {
612 Handle<PropertyDescriptorObject> Factory::NewPropertyDescriptorObject() {
624 Handle<SwissNameDictionary> Factory::CreateCanonicalEmptySwissNameDictionary() {
632 Handle<ByteArray> empty_meta_table =
646 Handle<String> Factory::InternalizeUtf8String(
665 Handle<String> Factory::InternalizeString(Handle<SeqString> string, int from,
672 template Handle<String> Factory::InternalizeString(
673 Handle<SeqOneByteString> string, int from, int length,
675 template Handle<String> Factory::InternalizeString(
676 Handle<SeqTwoByteString> string, int from, int length,
685 Handle<SeqOneByteString> result;
707 Handle<SeqOneByteString> result;
718 Handle<SeqTwoByteString> result;
729 Handle<SeqOneByteString> str, int begin, int length,
756 Handle<SeqOneByteString> result;
770 Handle<SeqTwoByteString> result;
790 Handle<SeqOneByteString> result;
797 Handle<SeqTwoByteString> result;
819 inline void WriteOneByteData(Handle<String> s, uint8_t* chars, int len) {
824 inline void WriteTwoByteData(Handle<String> s, uint16_t* chars, int len) {
832 Handle<String> Factory::AllocateInternalizedStringImpl(T t, int chars,
868 Handle<String> Factory::NewInternalizedStringImpl(Handle<String> string,
878 Handle<String> string, MaybeHandle<Map>* internalized_map) {
901 Handle<StringClass> Factory::InternalizeExternalString(Handle<String> string) {
902 Handle<Map> map =
916 template Handle<ExternalOneByteString>
917 Factory::InternalizeExternalString<ExternalOneByteString>(Handle<String>);
918 template Handle<ExternalTwoByteString>
919 Factory::InternalizeExternalString<ExternalTwoByteString>(Handle<String>);
922 Handle<String> string, MaybeHandle<Map>* shared_map) {
946 Handle<String> Factory::LookupSingleCharacterStringFromCode(uint16_t code) {
956 Handle<String> result =
965 Handle<String> Factory::NewSurrogatePairString(uint16_t lead, uint16_t trail) {
971 Handle<SeqTwoByteString> str =
980 Handle<String> Factory::NewProperSubString(Handle<String> str, int begin,
1005 Handle<SeqOneByteString> result =
1012 Handle<SeqTwoByteString> result =
1024 Handle<SlicedString> slice = Handle<SlicedString>::cast(str);
1025 str = Handle<String>(slice->parent(), isolate());
1029 Handle<ThinString> thin = Handle<ThinString>::cast(str);
1034 Handle<Map> map = str->IsOneByteRepresentation()
1054 Handle<Map> map = resource->IsCacheable()
1067 return Handle<String>(external_string, isolate());
1078 Handle<Map> map = resource->IsCacheable() ? external_string_map()
1090 return Handle<ExternalTwoByteString>(string, isolate());
1093 Handle<JSStringIterator> Factory::NewJSStringIterator(Handle<String> string) {
1094 Handle<Map> map(isolate()->native_context()->initial_string_iterator_map(),
1096 Handle<String> flat_string = String::Flatten(isolate(), string);
1097 Handle<JSStringIterator> iterator =
1098 Handle<JSStringIterator>::cast(NewJSObjectFromMap(map));
1126 Handle<Symbol> Factory::NewSymbol(AllocationType allocation) {
1130 Handle<Symbol> Factory::NewPrivateSymbol(AllocationType allocation) {
1138 Handle<Symbol> Factory::NewPrivateNameSymbol(Handle<String> name) {
1146 Context Factory::NewContextInternal(Handle<Map> map, int size,
1170 Handle<NativeContext> Factory::NewNativeContext() {
1171 Handle<Map> map = NewMap(NATIVE_CONTEXT_TYPE, kVariableSizeSentinel);
1192 Handle<Context> Factory::NewScriptContext(Handle<NativeContext> outer,
1193 Handle<ScopeInfo> scope_info) {
1207 Handle<ScriptContextTable> Factory::NewScriptContextTable() {
1208 Handle<ScriptContextTable> context_table = Handle<ScriptContextTable>::cast(
1211 Handle<NameToIndexHashTable> names = NameToIndexHashTable::New(isolate(), 16);
1217 Handle<Context> Factory::NewModuleContext(Handle<SourceTextModule> module,
1218 Handle<NativeContext> outer,
1219 Handle<ScopeInfo> scope_info) {
1233 Handle<Context> Factory::NewFunctionContext(Handle<Context> outer,
1234 Handle<ScopeInfo> scope_info) {
1235 Handle<Map> map;
1256 Handle<Context> Factory::NewCatchContext(Handle<Context> previous,
1257 Handle<ScopeInfo> scope_info,
1258 Handle<Object> thrown_object) {
1274 Handle<Context> Factory::NewDebugEvaluateContext(Handle<Context> previous,
1275 Handle<ScopeInfo> scope_info,
1276 Handle<JSReceiver> extension,
1277 Handle<Context> wrapped) {
1279 Handle<HeapObject> ext = extension.is_null()
1280 ? Handle<HeapObject>::cast(undefined_value())
1281 : Handle<HeapObject>::cast(extension);
1299 Handle<Context> Factory::NewWithContext(Handle<Context> previous,
1300 Handle<ScopeInfo> scope_info,
1301 Handle<JSReceiver> extension) {
1316 Handle<Context> Factory::NewBlockContext(Handle<Context> previous,
1317 Handle<ScopeInfo> scope_info) {
1331 Handle<Context> Factory::NewBuiltinContext(Handle<NativeContext> native_context,
1345 Handle<AliasedArgumentsEntry> Factory::NewAliasedArgumentsEntry(
1353 Handle<AccessorInfo> Factory::NewAccessorInfo() {
1369 Handle<ErrorStackData> Factory::NewErrorStackData(
1370 Handle<Object> call_site_infos_or_formatted_stack,
1371 Handle<Object> limit_or_stack_frame_infos) {
1382 void Factory::AddToScriptList(Handle<Script> script) {
1383 Handle<WeakArrayList> scripts = script_list();
1389 Handle<Script> Factory::CloneScript(Handle<Script> script) {
1393 Handle<ArrayList> list = ArrayList::New(isolate(), 0);
1395 Handle<Script> new_script_handle =
1396 Handle<Script>::cast(NewStruct(SCRIPT_TYPE, AllocationType::kOld));
1421 Handle<WeakArrayList> scripts = script_list();
1429 Handle<CallableTask> Factory::NewCallableTask(Handle<JSReceiver> callable,
1430 Handle<Context> context) {
1440 Handle<CallbackTask> Factory::NewCallbackTask(Handle<Foreign> callback,
1441 Handle<Foreign> data) {
1450 Handle<PromiseResolveThenableJobTask> Factory::NewPromiseResolveThenableJobTask(
1451 Handle<JSPromise> promise_to_resolve, Handle<JSReceiver> thenable,
1452 Handle<JSReceiver> then, Handle<Context> context) {
1464 Handle<Foreign> Factory::NewForeign(Address addr) {
1477 Handle<WasmTypeInfo> Factory::NewWasmTypeInfo(
1478 Address type_address, Handle<Map> opt_parent, int instance_size_bytes,
1479 Handle<WasmInstanceObject> instance) {
1489 Handle<FixedArray> supertypes;
1496 Handle<FixedArray> parent_supertypes =
1523 Handle<WasmApiFunctionRef> Factory::NewWasmApiFunctionRef(
1524 Handle<JSReceiver> callable, Handle<HeapObject> suspender) {
1544 Handle<WasmInternalFunction> Factory::NewWasmInternalFunction(
1545 Address opt_call_target, Handle<HeapObject> ref, Handle<Map> rtt) {
1559 Handle<WasmJSFunctionData> Factory::NewWasmJSFunctionData(
1560 Address opt_call_target, Handle<JSReceiver> callable, int return_count,
1561 int parameter_count, Handle<PodArray<wasm::ValueType>> serialized_sig,
1562 Handle<CodeT> wrapper_code, Handle<Map> rtt, Handle<HeapObject> suspender) {
1563 Handle<WasmApiFunctionRef> ref = NewWasmApiFunctionRef(callable, suspender);
1564 Handle<WasmInternalFunction> internal =
1579 Handle<WasmOnFulfilledData> Factory::NewWasmOnFulfilledData(
1580 Handle<WasmSuspenderObject> suspender) {
1590 Handle<WasmExportedFunctionData> Factory::NewWasmExportedFunctionData(
1591 Handle<CodeT> export_wrapper, Handle<WasmInstanceObject> instance,
1592 Address call_target, Handle<Object> ref, int func_index,
1593 Address sig_address, int wrapper_budget, Handle<Map> rtt) {
1594 Handle<Foreign> sig_foreign = NewForeign(sig_address);
1595 Handle<WasmInternalFunction> internal =
1596 NewWasmInternalFunction(call_target, Handle<HeapObject>::cast(ref), rtt);
1620 Handle<WasmCapiFunctionData> Factory::NewWasmCapiFunctionData(
1621 Address call_target, Handle<Foreign> embedder_data,
1622 Handle<CodeT> wrapper_code, Handle<Map> rtt,
1623 Handle<PodArray<wasm::ValueType>> serialized_sig) {
1624 Handle<WasmApiFunctionRef> ref =
1625 NewWasmApiFunctionRef(Handle<JSReceiver>(), Handle<HeapObject>());
1626 Handle<WasmInternalFunction> internal =
1640 Handle<WasmArray> Factory::NewWasmArrayFromElements(
1642 Handle<Map> map) {
1667 Handle<WasmArray> Factory::NewWasmArrayFromMemory(uint32_t length,
1668 Handle<Map> map,
1688 Handle<WasmStruct> Factory::NewWasmStruct(const wasm::StructType* type,
1690 Handle<Map> map) {
1709 Handle<SharedFunctionInfo>
1711 Handle<String> name, Handle<WasmExportedFunctionData> data) {
1715 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfoForWasmJSFunction(
1716 Handle<String> name, Handle<WasmJSFunctionData> data) {
1720 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfoForWasmOnFulfilled(
1721 Handle<WasmOnFulfilledData> data) {
1725 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfoForWasmCapiFunction(
1726 Handle<WasmCapiFunctionData> data) {
1733 Handle<Cell> Factory::NewCell(Handle<Object> value) {
1742 Handle<FeedbackCell> Factory::NewNoClosuresCell(Handle<HeapObject> value) {
1753 Handle<FeedbackCell> Factory::NewOneClosureCell(Handle<HeapObject> value) {
1764 Handle<FeedbackCell> Factory::NewManyClosuresCell(Handle<HeapObject> value) {
1775 Handle<PropertyCell> Factory::NewPropertyCell(Handle<Name> name,
1777 Handle<Object> value,
1796 Handle<PropertyCell> Factory::NewProtector() {
1802 Handle<TransitionArray> Factory::NewTransitionArray(int number_of_transitions,
1805 Handle<TransitionArray> array = Handle<TransitionArray>::cast(
1823 Handle<AllocationSite> Factory::NewAllocationSite(bool with_weak_next) {
1824 Handle<Map> map = with_weak_next ? allocation_site_map()
1826 Handle<AllocationSite> site(
1838 Handle<Map> Factory::NewMap(InstanceType type, int instance_size,
1907 Handle<JSObject> Factory::CopyJSObject(Handle<JSObject> source) {
1908 return CopyJSObjectWithAllocationSite(source, Handle<AllocationSite>());
1911 Handle<JSObject> Factory::CopyJSObjectWithAllocationSite(
1912 Handle<JSObject> source, Handle<AllocationSite> site) {
1913 Handle<Map> map(source->map(), isolate());
1948 Handle<JSObject> clone(JSObject::cast(raw_clone), isolate());
1984 Handle<PropertyArray> prop = CopyArrayWithMap(
1989 Handle<Object> copied_properties;
2022 Handle<T> Factory::CopyArrayWithMap(Handle<T> src, Handle<Map> map) {
2036 Handle<T> Factory::CopyArrayAndGrow(Handle<T> src, int grow_by,
2055 Handle<FixedArray> Factory::CopyFixedArrayWithMap(Handle<FixedArray> array,
2056 Handle<Map> map) {
2060 Handle<FixedArray> Factory::CopyFixedArrayAndGrow(Handle<FixedArray> array,
2065 Handle<WeakArrayList> Factory::NewUninitializedWeakArrayList(
2080 Handle<WeakArrayList> Factory::NewWeakArrayList(int capacity,
2082 Handle<WeakArrayList> result =
2089 Handle<WeakFixedArray> Factory::CopyWeakFixedArrayAndGrow(
2090 Handle<WeakFixedArray> src, int grow_by) {
2095 Handle<WeakArrayList> Factory::CopyWeakArrayListAndGrow(
2096 Handle<WeakArrayList> src, int grow_by, AllocationType allocation) {
2100 Handle<WeakArrayList> result =
2114 Handle<WeakArrayList> Factory::CompactWeakArrayList(Handle<WeakArrayList> src,
2117 Handle<WeakArrayList> result =
2138 Handle<PropertyArray> Factory::CopyPropertyArrayAndGrow(
2139 Handle<PropertyArray> array, int grow_by) {
2143 Handle<FixedArray> Factory::CopyFixedArrayUpTo(Handle<FixedArray> array,
2160 Handle<FixedArray> Factory::CopyFixedArray(Handle<FixedArray> array) {
2165 Handle<FixedDoubleArray> Factory::CopyFixedDoubleArray(
2166 Handle<FixedDoubleArray> array) {
2169 Handle<FixedDoubleArray> result =
2170 Handle<FixedDoubleArray>::cast(NewFixedDoubleArray(len));
2178 Handle<HeapNumber> Factory::NewHeapNumberForCodeAssembler(double value) {
2184 Handle<JSObject> Factory::NewError(Handle<JSFunction> constructor,
2186 Handle<Object> arg0, Handle<Object> arg1,
2187 Handle<Object> arg2) {
2198 Handle<JSObject> Factory::NewError(Handle<JSFunction> constructor,
2199 Handle<String> message) {
2203 Handle<Object> no_caller;
2210 Handle<Object> Factory::NewInvalidStringLengthError() {
2222 Handle<JSObject> Factory::New##NAME( \
2223 MessageTemplate template_index, Handle<Object> arg0, \
2224 Handle<Object> arg1, Handle<Object> arg2) { \
2240 Handle<JSObject> Factory::NewFunctionPrototype(Handle<JSFunction> function) {
2243 Handle<NativeContext> native_context(function->native_context(), isolate());
2244 Handle<Map> new_map;
2256 Handle<JSFunction> object_function(native_context->object_function(),
2263 Handle<JSObject> prototype = NewJSObjectFromMap(new_map);
2273 Handle<JSObject> Factory::NewExternal(void* value) {
2275 Handle<JSExternalObject>::cast(NewJSObjectFromMap(external_map()));
2281 Handle<DeoptimizationLiteralArray> Factory::NewDeoptimizationLiteralArray(
2283 return Handle<DeoptimizationLiteralArray>::cast(
2287 Handle<Code> Factory::NewOffHeapTrampolineFor(Handle<Code> code,
2295 Handle<Code> result = Builtins::GenerateOffHeapTrampolineFor(
2356 Handle<Code> Factory::CopyCode(Handle<Code> code) {
2357 Handle<CodeDataContainer> data_container = NewCodeDataContainer(
2362 Handle<Code> new_code;
2403 Handle<BytecodeArray> Factory::CopyBytecodeArray(Handle<BytecodeArray> source) {
2424 Handle<JSObject> Factory::NewJSObject(Handle<JSFunction> constructor,
2427 Handle<Map> map(constructor->initial_map(), isolate());
2431 Handle<JSObject> Factory::NewSlowJSObjectWithNullProto() {
2432 Handle<JSObject> result =
2437 Handle<JSObject> Factory::NewJSObjectWithNullProto() {
2438 Handle<Map> map(isolate()->object_function()->initial_map(), isolate());
2439 Handle<Map> map_with_null_proto =
2444 Handle<JSGlobalObject> Factory::NewJSGlobalObject(
2445 Handle<JSFunction> constructor) {
2447 Handle<Map> map(constructor->initial_map(), isolate());
2467 Handle<GlobalDictionary> dictionary =
2472 Handle<DescriptorArray> descs(map->instance_descriptors(isolate()),
2480 Handle<Name> name(descs->GetKey(i), isolate());
2481 Handle<Object> value(descs->GetStrongValue(i), isolate());
2482 Handle<PropertyCell> cell = NewPropertyCell(name, d, value);
2488 Handle<JSGlobalObject> global(
2493 Handle<Map> new_map = Map::CopyDropDescriptors(isolate(), map);
2546 Handle<JSObject> Factory::NewJSObjectFromMap(
2547 Handle<Map> map, AllocationType allocation,
2548 Handle<AllocationSite> allocation_site) {
2569 Handle<JSObject> Factory::NewSlowJSObjectFromMap(
2570 Handle<Map> map, int capacity, AllocationType allocation,
2571 Handle<AllocationSite> allocation_site) {
2573 Handle<HeapObject> object_properties;
2579 Handle<JSObject> js_object =
2585 Handle<JSObject> Factory::NewSlowJSObjectWithPropertiesAndElements(
2586 Handle<HeapObject> prototype, Handle<HeapObject> properties,
2587 Handle<FixedArrayBase> elements) {
2593 Handle<Map> object_map = isolate()->slow_object_with_object_prototype_map();
2598 Handle<JSObject> object =
2611 Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind, int length,
2622 Handle<FixedArrayBase> elms =
2628 Handle<JSArray> Factory::NewJSArrayWithElements(Handle<FixedArrayBase> elements,
2632 Handle<JSArray> array = NewJSArrayWithUnverifiedElements(
2638 Handle<JSArray> Factory::NewJSArrayWithUnverifiedElements(
2639 Handle<FixedArrayBase> elements, ElementsKind elements_kind, int length,
2648 Handle<JSArray> array = Handle<JSArray>::cast(
2657 void Factory::NewJSArrayStorage(Handle<JSArray> array, int length, int capacity,
2670 Handle<FixedArrayBase> elms =
2678 Handle<FixedArrayBase> Factory::NewJSArrayStorage(
2681 Handle<FixedArrayBase> elms;
2701 Handle<JSWeakMap> Factory::NewJSWeakMap() {
2703 Handle<Map> map(native_context.js_weak_map_fun().initial_map(), isolate());
2704 Handle<JSWeakMap> weakmap(JSWeakMap::cast(*NewJSObjectFromMap(map)),
2714 Handle<JSModuleNamespace> Factory::NewJSModuleNamespace() {
2715 Handle<Map> map = isolate()->js_module_namespace_map();
2716 Handle<JSModuleNamespace> module_namespace(
2717 Handle<JSModuleNamespace>::cast(NewJSObjectFromMap(map)));
2725 Handle<JSWrappedFunction> Factory::NewJSWrappedFunction(
2726 Handle<NativeContext> creation_context, Handle<Object> target) {
2728 Handle<Map> map(
2735 Handle<JSWrappedFunction> wrapped = Handle<JSWrappedFunction>::cast(
2746 Handle<JSGeneratorObject> Factory::NewJSGeneratorObject(
2747 Handle<JSFunction> function) {
2750 Handle<Map> map(function->initial_map(), isolate());
2755 return Handle<JSGeneratorObject>::cast(NewJSObjectFromMap(map));
2758 Handle<SourceTextModule> Factory::NewSourceTextModule(
2759 Handle<SharedFunctionInfo> sfi) {
2760 Handle<SourceTextModuleInfo> module_info(
2762 Handle<ObjectHashTable> exports =
2764 Handle<FixedArray> regular_exports =
2766 Handle<FixedArray> regular_imports =
2769 Handle<FixedArray> requested_modules =
2800 Handle<SyntheticModule> Factory::NewSyntheticModule(
2801 Handle<String> module_name, Handle<FixedArray> export_names,
2805 Handle<ObjectHashTable> exports =
2807 Handle<Foreign> evaluation_steps_foreign =
2825 Handle<JSArrayBuffer> Factory::NewJSArrayBuffer(
2827 Handle<Map> map(isolate()->native_context()->array_buffer_fun().initial_map(),
2830 Handle<JSArrayBuffer>::cast(NewJSObjectFromMap(map, allocation));
2846 Handle<Map> map(isolate()->native_context()->array_buffer_fun().initial_map(),
2849 Handle<JSArrayBuffer>::cast(NewJSObjectFromMap(map, allocation));
2855 Handle<JSArrayBuffer> Factory::NewJSSharedArrayBuffer(
2858 Handle<Map> map(
2861 auto result = Handle<JSArrayBuffer>::cast(
2870 Handle<JSIteratorResult> Factory::NewJSIteratorResult(Handle<Object> value,
2872 Handle<Map> map(isolate()->native_context()->iterator_result_map(),
2874 Handle<JSIteratorResult> js_iter_result = Handle<JSIteratorResult>::cast(
2883 Handle<JSAsyncFromSyncIterator> Factory::NewJSAsyncFromSyncIterator(
2884 Handle<JSReceiver> sync_iterator, Handle<Object> next) {
2885 Handle<Map> map(isolate()->native_context()->async_from_sync_iterator_map(),
2887 Handle<JSAsyncFromSyncIterator> iterator =
2888 Handle<JSAsyncFromSyncIterator>::cast(
2897 Handle<JSMap> Factory::NewJSMap() {
2898 Handle<Map> map(isolate()->native_context()->js_map_map(), isolate());
2899 Handle<JSMap> js_map = Handle<JSMap>::cast(NewJSObjectFromMap(map));
2904 Handle<JSSet> Factory::NewJSSet() {
2905 Handle<Map> map(isolate()->native_context()->js_set_map(), isolate());
2906 Handle<JSSet> js_set = Handle<JSSet>::cast(NewJSObjectFromMap(map));
2948 Handle<JSArrayBufferView> Factory::NewJSArrayBufferView(
2949 Handle<Map> map, Handle<FixedArrayBase> elements,
2950 Handle<JSArrayBuffer> buffer, size_t byte_offset, size_t byte_length) {
2954 Handle<JSArrayBufferView> array_buffer_view = Handle<JSArrayBufferView>::cast(
2970 Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type,
2971 Handle<JSArrayBuffer> buffer,
2983 Handle<Map> map;
2998 Handle<JSTypedArray> typed_array =
2999 Handle<JSTypedArray>::cast(NewJSArrayBufferView(
3010 Handle<JSDataView> Factory::NewJSDataView(Handle<JSArrayBuffer> buffer,
3013 Handle<Map> map(isolate()->native_context()->data_view_fun().initial_map(),
3015 Handle<JSDataView> obj = Handle<JSDataView>::cast(NewJSArrayBufferView(
3026 Handle<JSReceiver> target_function, Handle<Object> bound_this,
3027 base::Vector<Handle<Object>> bound_args) {
3037 Handle<HeapObject> prototype;
3046 Handle<FixedArray> bound_arguments;
3057 Handle<Map> map = target_function->IsConstructor()
3066 Handle<JSBoundFunction> result = Handle<JSBoundFunction>::cast(
3077 Handle<JSProxy> Factory::NewJSProxy(Handle<JSReceiver> target,
3078 Handle<JSReceiver> handler) {
3080 Handle<Map> map;
3083 map = Handle<Map>(isolate()->proxy_constructor_map());
3085 map = Handle<Map>(isolate()->proxy_callable_map());
3088 map = Handle<Map>(isolate()->proxy_map());
3099 Handle<JSGlobalProxy> Factory::NewUninitializedJSGlobalProxy(int size) {
3102 Handle<Map> map = NewMap(JS_GLOBAL_PROXY_TYPE, size);
3111 Handle<JSGlobalProxy> proxy = Handle<JSGlobalProxy>::cast(
3119 void Factory::ReinitializeJSGlobalProxy(Handle<JSGlobalProxy> object,
3120 Handle<JSFunction> constructor) {
3122 Handle<Map> map(constructor->initial_map(), isolate());
3123 Handle<Map> old_map(object->map(), isolate());
3126 Handle<Object> raw_properties_or_hash(object->raw_properties_or_hash(),
3153 Handle<JSMessageObject> Factory::NewJSMessageObject(
3154 MessageTemplate message, Handle<Object> argument, int start_position,
3155 int end_position, Handle<SharedFunctionInfo> shared_info,
3156 int bytecode_offset, Handle<Script> script, Handle<Object> stack_frames) {
3157 Handle<Map> map = message_object_map();
3192 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfoForApiFunction(
3194 Handle<FunctionTemplateInfo> function_template_info, FunctionKind kind) {
3195 Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(
3200 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfoForBuiltin(
3202 Handle<SharedFunctionInfo> shared =
3207 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfoForWebSnapshot() {
3214 V8_INLINE int NumberToStringCacheHash(Handle<FixedArray> cache, Smi number) {
3219 V8_INLINE int NumberToStringCacheHash(Handle<FixedArray> cache, double number) {
3225 V8_INLINE Handle<String> CharToString(Factory* factory, const char* string,
3237 void Factory::NumberToStringCacheSet(Handle<Object> number, int hash,
3238 Handle<String> js_string) {
3243 Handle<FixedArray> new_cache =
3255 Handle<Object> Factory::NumberToStringCacheGet(Object number, int hash) {
3261 return Handle<String>(String::cast(cache.get(hash * 2 + 1)), isolate());
3266 Handle<String> Factory::NumberToString(Handle<Object> number,
3271 double double_value = Handle<HeapNumber>::cast(number)->value();
3277 return HeapNumberToString(Handle<HeapNumber>::cast(number), double_value,
3284 Handle<String> Factory::HeapNumberToString(Handle<HeapNumber> number,
3291 Handle<Object> cached = NumberToStringCacheGet(*number, hash);
3292 if (!cached->IsUndefined(isolate())) return Handle<String>::cast(cached);
3295 Handle<String> result;
3312 inline Handle<String> Factory::SmiToString(Smi number, NumberCacheMode mode) {
3315 Handle<Object> cached = NumberToStringCacheGet(number, hash);
3316 if (!cached->IsUndefined(isolate())) return Handle<String>::cast(cached);
3319 Handle<String> result;
3348 Handle<String> Factory::SizeToString(size_t value, bool check_cache) {
3349 Handle<String> result;
3388 Handle<DebugInfo> Factory::NewDebugInfo(Handle<SharedFunctionInfo> shared) {
3413 Handle<BreakPointInfo> Factory::NewBreakPointInfo(int source_position) {
3422 Handle<BreakPoint> Factory::NewBreakPoint(int id, Handle<String> condition) {
3431 Handle<CallSiteInfo> Factory::NewCallSiteInfo(
3432 Handle<Object> receiver_or_instance, Handle<Object> function,
3433 Handle<HeapObject> code_object, int code_offset_or_source_position,
3434 int flags, Handle<FixedArray> parameters) {
3447 Handle<StackFrameInfo> Factory::NewStackFrameInfo(
3448 Handle<HeapObject> shared_or_script, int bytecode_offset_or_source_position,
3449 Handle<String> function_name, bool is_constructor) {
3463 Handle<PromiseOnStack> Factory::NewPromiseOnStack(Handle<Object> prev,
3464 Handle<JSObject> promise) {
3473 Handle<JSObject> Factory::NewArgumentsObject(Handle<JSFunction> callee,
3477 Handle<Map> map = strict_mode_callee ? isolate()->strict_arguments_map()
3479 AllocationSiteUsageContext context(isolate(), Handle<AllocationSite>(),
3482 Handle<JSObject> result = NewJSObjectFromMap(map);
3483 Handle<Smi> value(Smi::FromInt(length), isolate());
3497 Handle<Map> Factory::ObjectLiteralMapFromCache(Handle<NativeContext> context,
3504 Handle<WeakFixedArray> cache(WeakFixedArray::cast(context->map_cache()),
3517 Handle<Map> map = Map::Create(isolate(), number_of_properties);
3523 Handle<MegaDomHandler> Factory::NewMegaDomHandler(MaybeObjectHandle accessor,
3525 Handle<Map> map = read_only_roots().mega_dom_handler_map_handle();
3533 Handle<LoadHandler> Factory::NewLoadHandler(int data_count,
3535 Handle<Map> map;
3552 Handle<StoreHandler> Factory::NewStoreHandler(int data_count) {
3553 Handle<Map> map;
3573 void Factory::SetRegExpAtomData(Handle<JSRegExp> regexp, Handle<String> source,
3574 JSRegExp::Flags flags, Handle<Object> data) {
3585 void Factory::SetRegExpIrregexpData(Handle<JSRegExp> regexp,
3586 Handle<String> source,
3612 void Factory::SetRegExpExperimentalData(Handle<JSRegExp> regexp,
3613 Handle<String> source,
3636 Handle<RegExpMatchInfo> Factory::NewRegExpMatchInfo() {
3642 Handle<FixedArray> elems =
3644 Handle<RegExpMatchInfo> result = Handle<RegExpMatchInfo>::cast(elems);
3657 Handle<Object> Factory::GlobalConstantFor(Handle<Name> name) {
3663 return Handle<Object>::null();
3666 Handle<String> Factory::ToPrimitiveHintString(ToPrimitiveHint hint) {
3678 Handle<Map> Factory::CreateSloppyFunctionMap(
3687 Handle<Map> map = NewMap(
3697 Handle<JSFunction> empty_function;
3727 Handle<Name> name = isolate()->factory()->name_string();
3764 Handle<Map> Factory::CreateStrictFunctionMap(
3765 FunctionMode function_mode, Handle<JSFunction> empty_function) {
3779 Handle<Map> map = NewMap(
3814 Handle<Name> name = isolate()->factory()->name_string();
3842 Handle<Map> Factory::CreateClassFunctionMap(Handle<JSFunction> empty_function) {
3843 Handle<Map> map =
3882 Handle<JSPromise> Factory::NewJSPromiseWithoutHook() {
3883 Handle<JSPromise> promise =
3884 Handle<JSPromise>::cast(NewJSObject(isolate()->promise_function()));
3895 Handle<JSPromise> Factory::NewJSPromise() {
3896 Handle<JSPromise> promise = NewJSPromiseWithoutHook();
3902 Handle<CallHandlerInfo> Factory::NewCallHandlerInfo(bool has_no_side_effect) {
3903 Handle<Map> map = has_no_side_effect
3929 Handle<JSFunction> Factory::NewFunctionForTesting(Handle<String> name) {
3930 Handle<SharedFunctionInfo> info =
3938 Handle<SharedFunctionInfo> sfi,
3939 Handle<Context> context)
3942 Handle<JSFunction> Factory::JSFunctionBuilder::Build() {
3946 Handle<Code> code = handle(FromCodeT(sfi_->GetCode()), isolate_);
3947 Handle<JSFunction> result = BuildRaw(code);
3958 Handle<JSFunction> Factory::JSFunctionBuilder::BuildRaw(Handle<Code> code) {
3962 Handle<Map> map = maybe_map_.ToHandleChecked();
3963 Handle<FeedbackCell> feedback_cell = maybe_feedback_cell_.ToHandleChecked();
4004 Handle<FeedbackCell> feedback_cell;