Lines Matching refs:Handle
16 Handle<T> Factory::New(Handle<Map> map, AllocationSpace space) {
25 Handle<T> Factory::New(Handle<Map> map,
27 Handle<AllocationSite> allocation_site) {
35 Handle<HeapObject> Factory::NewFillerObject(int size,
45 Handle<Box> Factory::NewBox(Handle<Object> value) {
46 Handle<Box> result = Handle<Box>::cast(NewStruct(BOX_TYPE));
52 Handle<Oddball> Factory::NewOddball(Handle<Map> map,
54 Handle<Object> to_number,
56 Handle<Oddball> oddball = New<Oddball>(map, OLD_POINTER_SPACE);
62 Handle<FixedArray> Factory::NewFixedArray(int size, PretenureFlag pretenure) {
71 Handle<FixedArray> Factory::NewFixedArrayWithHoles(int size,
83 Handle<FixedArray> Factory::NewUninitializedFixedArray(int size) {
91 Handle<FixedArrayBase> Factory::NewFixedDoubleArray(int size,
101 Handle<FixedArrayBase> Factory::NewFixedDoubleArrayWithHoles(
105 Handle<FixedArrayBase> array = NewFixedDoubleArray(size, pretenure);
107 Handle<FixedDoubleArray> double_array =
108 Handle<FixedDoubleArray>::cast(array);
117 Handle<ConstantPoolArray> Factory::NewConstantPoolArray(
127 Handle<ConstantPoolArray> Factory::NewExtendedConstantPoolArray(
139 Handle<OrderedHashSet> Factory::NewOrderedHashSet() {
144 Handle<OrderedHashMap> Factory::NewOrderedHashMap() {
149 Handle<AccessorPair> Factory::NewAccessorPair() {
150 Handle<AccessorPair> accessors =
151 Handle<AccessorPair>::cast(NewStruct(ACCESSOR_PAIR_TYPE));
159 Handle<TypeFeedbackInfo> Factory::NewTypeFeedbackInfo() {
160 Handle<TypeFeedbackInfo> info =
161 Handle<TypeFeedbackInfo>::cast(NewStruct(TYPE_FEEDBACK_INFO_TYPE));
168 Handle<String> Factory::InternalizeUtf8String(Vector<const char> string) {
175 Handle<String> Factory::InternalizeString(Handle<String> string) {
181 Handle<String> Factory::InternalizeOneByteString(Vector<const uint8_t> string) {
187 Handle<String> Factory::InternalizeOneByteString(
188 Handle<SeqOneByteString> string, int from, int length) {
194 Handle<String> Factory::InternalizeTwoByteString(Vector<const uc16> string) {
201 Handle<String> Factory::InternalizeStringWithKey(StringTableKey* key) {
206 template Handle<String> Factory::InternalizeStringWithKey<
208 template Handle<String> Factory::InternalizeStringWithKey<
216 Handle<SeqOneByteString> result;
251 Handle<SeqTwoByteString> result;
273 Handle<SeqOneByteString> result;
282 Handle<SeqTwoByteString> result;
294 Handle<String> Factory::NewInternalizedStringFromUtf8(Vector<const char> str,
305 MUST_USE_RESULT Handle<String> Factory::NewOneByteInternalizedString(
315 MUST_USE_RESULT Handle<String> Factory::NewTwoByteInternalizedString(
325 Handle<String> Factory::NewInternalizedStringImpl(
326 Handle<String> string, int chars, uint32_t hash_field) {
336 Handle<String> string) {
384 Handle<String> Factory::LookupSingleCharacterStringFromCode(uint32_t code) {
390 return handle(String::cast(value), isolate());
395 Handle<String> result =
402 Handle<SeqTwoByteString> result = NewRawTwoByteString(1).ToHandleChecked();
415 static inline Handle<String> MakeOrFindTwoCharacterString(Isolate* isolate,
421 Handle<String> result;
433 Handle<SeqOneByteString> str =
440 Handle<SeqTwoByteString> str =
451 Handle<String> ConcatStringContent(Handle<StringType> result,
452 Handle<String> first,
453 Handle<String> second) {
462 MaybeHandle<String> Factory::NewConsString(Handle<String> left,
463 Handle<String> right) {
507 Handle<SeqOneByteString> result =
513 ? Handle<ExternalAsciiString>::cast(left)->GetChars()
514 : Handle<SeqOneByteString>::cast(left)->GetChars();
518 ? Handle<ExternalAsciiString>::cast(right)->GetChars()
519 : Handle<SeqOneByteString>::cast(right)->GetChars();
531 Handle<Map> map = (is_one_byte || is_one_byte_data_in_two_byte_string)
533 Handle<ConsString> result = New<ConsString>(map, NEW_SPACE);
546 Handle<String> Factory::NewFlatConcatString(Handle<String> first,
547 Handle<String> second) {
559 Handle<String> Factory::NewProperSubString(Handle<String> str,
585 Handle<SeqOneByteString> result =
592 Handle<SeqTwoByteString> result =
604 Handle<SlicedString> slice = Handle<SlicedString>::cast(str);
605 str = Handle<String>(slice->parent(), isolate());
610 Handle<Map> map = str->IsOneByteRepresentation() ? sliced_ascii_string_map()
612 Handle<SlicedString> slice = New<SlicedString>(map, NEW_SPACE);
629 Handle<Map> map = external_ascii_string_map();
630 Handle<ExternalAsciiString> external_string =
652 Handle<Map> map = is_one_byte ?
654 Handle<ExternalTwoByteString> external_string =
664 Handle<Symbol> Factory::NewSymbol() {
672 Handle<Symbol> Factory::NewPrivateSymbol() {
673 Handle<Symbol> symbol = NewSymbol();
679 Handle<Context> Factory::NewNativeContext() {
680 Handle<FixedArray> array = NewFixedArray(Context::NATIVE_CONTEXT_SLOTS);
682 Handle<Context> context = Handle<Context>::cast(array);
689 Handle<Context> Factory::NewGlobalContext(Handle<JSFunction> function,
690 Handle<ScopeInfo> scope_info) {
691 Handle<FixedArray> array =
694 Handle<Context> context = Handle<Context>::cast(array);
704 Handle<Context> Factory::NewModuleContext(Handle<ScopeInfo> scope_info) {
705 Handle<FixedArray> array =
709 Handle<Context> context = Handle<Context>::cast(array);
715 Handle<Context> Factory::NewFunctionContext(int length,
716 Handle<JSFunction> function) {
718 Handle<FixedArray> array = NewFixedArray(length);
720 Handle<Context> context = Handle<Context>::cast(array);
729 Handle<Context> Factory::NewCatchContext(Handle<JSFunction> function,
730 Handle<Context> previous,
731 Handle<String> name,
732 Handle<Object> thrown_object) {
734 Handle<FixedArray> array = NewFixedArray(Context::MIN_CONTEXT_SLOTS + 1);
736 Handle<Context> context = Handle<Context>::cast(array);
746 Handle<Context> Factory::NewWithContext(Handle<JSFunction> function,
747 Handle<Context> previous,
748 Handle<JSReceiver> extension) {
749 Handle<FixedArray> array = NewFixedArray(Context::MIN_CONTEXT_SLOTS);
751 Handle<Context> context = Handle<Context>::cast(array);
760 Handle<Context> Factory::NewBlockContext(Handle<JSFunction> function,
761 Handle<Context> previous,
762 Handle<ScopeInfo> scope_info) {
763 Handle<FixedArray> array =
766 Handle<Context> context = Handle<Context>::cast(array);
775 Handle<Struct> Factory::NewStruct(InstanceType type) {
783 Handle<CodeCache> Factory::NewCodeCache() {
784 Handle<CodeCache> code_cache =
785 Handle<CodeCache>::cast(NewStruct(CODE_CACHE_TYPE));
792 Handle<AliasedArgumentsEntry> Factory::NewAliasedArgumentsEntry(
794 Handle<AliasedArgumentsEntry> entry = Handle<AliasedArgumentsEntry>::cast(
801 Handle<DeclaredAccessorDescriptor> Factory::NewDeclaredAccessorDescriptor() {
802 return Handle<DeclaredAccessorDescriptor>::cast(
807 Handle<DeclaredAccessorInfo> Factory::NewDeclaredAccessorInfo() {
808 Handle<DeclaredAccessorInfo> info =
809 Handle<DeclaredAccessorInfo>::cast(
816 Handle<ExecutableAccessorInfo> Factory::NewExecutableAccessorInfo() {
817 Handle<ExecutableAccessorInfo> info =
818 Handle<ExecutableAccessorInfo>::cast(
825 Handle<Script> Factory::NewScript(Handle<String> source) {
833 Handle<Foreign> wrapper = NewForeign(0, TENURED);
834 Handle<Script> script = Handle<Script>::cast(NewStruct(SCRIPT_TYPE));
852 Handle<Foreign> Factory::NewForeign(Address addr, PretenureFlag pretenure) {
859 Handle<Foreign> Factory::NewForeign(const AccessorDescriptor* desc) {
864 Handle<ByteArray> Factory::NewByteArray(int length, PretenureFlag pretenure) {
873 Handle<ExternalArray> Factory::NewExternalArray(int length,
888 Handle<FixedTypedArrayBase> Factory::NewFixedTypedArray(
902 Handle<Cell> Factory::NewCell(Handle<Object> value) {
911 Handle<PropertyCell> Factory::NewPropertyCellWithHole() {
919 Handle<PropertyCell> Factory::NewPropertyCell(Handle<Object> value) {
921 Handle<PropertyCell> cell = NewPropertyCellWithHole();
927 Handle<AllocationSite> Factory::NewAllocationSite() {
928 Handle<Map> map = allocation_site_map();
929 Handle<AllocationSite> site = New<AllocationSite>(map, OLD_POINTER_SPACE);
939 Handle<Map> Factory::NewMap(InstanceType type,
949 Handle<JSObject> Factory::CopyJSObject(Handle<JSObject> object) {
956 Handle<JSObject> Factory::CopyJSObjectWithAllocationSite(
957 Handle<JSObject> object,
958 Handle<AllocationSite> site) {
967 Handle<FixedArray> Factory::CopyFixedArrayWithMap(Handle<FixedArray> array,
968 Handle<Map> map) {
975 HandleHandle<FixedArray> array) {
982 Handle<FixedArray> Factory::CopyAndTenureFixedCOWArray(
983 Handle<FixedArray> array) {
991 Handle<FixedDoubleArray> Factory::CopyFixedDoubleArray(
992 Handle<FixedDoubleArray> array) {
999 Handle<ConstantPoolArray> Factory::CopyConstantPoolArray(
1000 Handle<ConstantPoolArray> array) {
1007 Handle<Object> Factory::NewNumber(double value,
1016 return handle(Smi::FromInt(int_value), isolate());
1024 Handle<Object> Factory::NewNumberFromInt(int32_t value,
1026 if (Smi::IsValid(value)) return handle(Smi::FromInt(value), isolate());
1032 Handle<Object> Factory::NewNumberFromUint(uint32_t value,
1036 return handle(Smi::FromInt(int32v), isolate());
1042 Handle<HeapNumber> Factory::NewHeapNumber(double value,
1050 Handle<Object> Factory::NewTypeError(const char* message,
1051 Vector< Handle<Object> > args) {
1056 Handle<Object> Factory::NewTypeError(Handle<String> message) {
1061 Handle<Object> Factory::NewRangeError(const char* message,
1062 Vector< Handle<Object> > args) {
1067 Handle<Object> Factory::NewRangeError(Handle<String> message) {
1072 Handle<Object> Factory::NewSyntaxError(const char* message,
1073 Handle<JSArray> args) {
1078 Handle<Object> Factory::NewSyntaxError(Handle<String> message) {
1083 Handle<Object> Factory::NewReferenceError(const char* message,
1084 Vector< Handle<Object> > args) {
1089 Handle<Object> Factory::NewReferenceError(const char* message,
1090 Handle<JSArray> args) {
1095 Handle<Object> Factory::NewReferenceError(Handle<String> message) {
1100 Handle<Object> Factory::NewError(const char* maker,
1102 Vector< Handle<Object> > args) {
1105 Handle<FixedArray> array = NewFixedArray(args.length());
1109 Handle<JSArray> object = NewJSArrayWithElements(array);
1110 Handle<Object> result = NewError(maker, message, object);
1115 Handle<Object> Factory::NewEvalError(const char* message,
1116 Vector< Handle<Object> > args) {
1121 Handle<Object> Factory::NewError(const char* message,
1122 Vector< Handle<Object> > args) {
1127 Handle<String> Factory::EmergencyNewError(const char* message,
1128 Handle<JSArray> args) {
1144 Handle<String> arg_str = Handle<String>::cast(
1163 Handle<Object> Factory::NewError(const char* maker,
1165 Handle<JSArray> args) {
1166 Handle<String> make_str = InternalizeUtf8String(maker);
1167 Handle<Object> fun_obj = Object::GetProperty(
1174 Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
1175 Handle<Object> message_obj = InternalizeUtf8String(message);
1176 Handle<Object> argv[] = { message_obj, args };
1180 Handle<Object> result;
1181 Handle<Object> exception;
1193 Handle<Object> Factory::NewError(Handle<String> message) {
1198 Handle<Object> Factory::NewError(const char* constructor,
1199 Handle<String> message) {
1200 Handle<String> constr = InternalizeUtf8String(constructor);
1201 Handle<JSFunction> fun = Handle<JSFunction>::cast(Object::GetProperty(
1203 Handle<Object> argv[] = { message };
1207 Handle<Object> result;
1208 Handle<Object> exception;
1220 void Factory::InitializeFunction(Handle<JSFunction> function,
1221 Handle<SharedFunctionInfo> info,
1222 Handle<Context> context) {
1234 Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
1235 Handle<SharedFunctionInfo> info,
1236 Handle<Context> context,
1239 Handle<JSFunction> result = New<JSFunction>(map, space);
1245 Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
1246 Handle<String> name,
1248 Handle<Context> context(isolate()->context()->native_context());
1249 Handle<SharedFunctionInfo> info = NewSharedFunctionInfo(name, code);
1260 Handle<JSFunction> Factory::NewFunction(Handle<String> name) {
1266 Handle<JSFunction> Factory::NewFunctionWithoutPrototype(Handle<String> name,
1267 Handle<Code> code) {
1273 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
1274 Handle<Code> code,
1275 Handle<Object> prototype,
1277 Handle<Map> map = read_only_prototype
1280 Handle<JSFunction> result = NewFunction(map, name, code);
1286 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
1287 Handle<Code> code,
1288 Handle<Object> prototype,
1293 Handle<JSFunction> function = NewFunction(
1296 Handle<Map> initial_map = NewMap(
1309 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
1310 Handle<Code> code,
1317 Handle<JSObject> Factory::NewFunctionPrototype(Handle<JSFunction> function) {
1320 Handle<Context> native_context(function->context()->native_context());
1321 Handle<Map> new_map;
1325 new_map = handle(native_context->generator_object_prototype_map());
1329 Handle<JSFunction> object_function(native_context->object_function());
1331 new_map = Map::Copy(handle(object_function->initial_map()));
1334 Handle<JSObject> prototype = NewJSObjectFromMap(new_map);
1347 Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
1348 Handle<SharedFunctionInfo> info,
1349 Handle<Context> context,
1353 Handle<Map> map(Map::cast(context->native_context()->get(map_index)));
1354 Handle<JSFunction> result = NewFunction(map, info, context, pretenure);
1364 Handle<FixedArray> literals = NewFixedArray(number_of_literals, pretenure);
1398 Handle<JSObject> Factory::NewIteratorResultObject(Handle<Object> value,
1400 Handle<Map> map(isolate()->native_context()->iterator_result_map());
1401 Handle<JSObject> result = NewJSObjectFromMap(map, NOT_TENURED, false);
1410 Handle<ScopeInfo> Factory::NewScopeInfo(int length) {
1411 Handle<FixedArray> array = NewFixedArray(length, TENURED);
1413 Handle<ScopeInfo> scope_info = Handle<ScopeInfo>::cast(array);
1418 Handle<JSObject> Factory::NewExternal(void* value) {
1419 Handle<Foreign> foreign = NewForeign(static_cast<Address>(value));
1420 Handle<JSObject> external = NewJSObjectFromMap(external_map());
1426 Handle<Code> Factory::NewCodeRaw(int object_size, bool immovable) {
1433 Handle<Code> Factory::NewCode(const CodeDesc& desc,
1435 Handle<Object> self_ref,
1440 Handle<ByteArray> reloc_info = NewByteArray(desc.reloc_size, TENURED);
1441 Handle<ConstantPoolArray> constant_pool =
1448 Handle<Code> code = NewCodeRaw(obj_size, immovable);
1481 // Allow self references to created code object by patching the handle to
1499 Handle<Code> Factory::CopyCode(Handle<Code> code) {
1506 Handle<Code> Factory::CopyCode(Handle<Code> code, Vector<byte> reloc_info) {
1513 Handle<JSObject> Factory::NewJSObject(Handle<JSFunction> constructor,
1522 Handle<JSObject> Factory::NewJSObjectWithMemento(
1523 Handle<JSFunction> constructor,
1524 Handle<AllocationSite> site) {
1533 Handle<JSModule> Factory::NewJSModule(Handle<Context> context,
1534 Handle<ScopeInfo> scope_info) {
1536 Handle<Map> map = NewMap(JS_MODULE_TYPE, JSModule::kSize);
1538 Handle<JSModule> module =
1539 Handle<JSModule>::cast(NewJSObjectFromMap(map, TENURED));
1546 Handle<GlobalObject> Factory::NewGlobalObject(Handle<JSFunction> constructor) {
1548 Handle<Map> map(constructor->initial_map());
1568 Handle<NameDictionary> dictionary =
1573 Handle<DescriptorArray> descs(map->instance_descriptors());
1578 Handle<Name> name(descs->GetKey(i));
1579 Handle<Object> value(descs->GetCallbacksObject(i), isolate());
1580 Handle<PropertyCell> cell = NewPropertyCell(value);
1586 Handle<GlobalObject> global = New<GlobalObject>(map, OLD_POINTER_SPACE);
1590 Handle<Map> new_map = Map::CopyDropDescriptors(map);
1603 Handle<JSObject> Factory::NewJSObjectFromMap(
1604 Handle<Map> map,
1607 Handle<AllocationSite> allocation_site) {
1619 Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind,
1626 return Handle<JSArray>::cast(NewJSObjectFromMap(handle(map), pretenure));
1630 Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind,
1635 Handle<JSArray> array = NewJSArray(elements_kind, pretenure);
1641 Handle<JSArray> Factory::NewJSArrayWithElements(Handle<FixedArrayBase> elements,
1646 Handle<JSArray> array = NewJSArray(elements_kind, pretenure);
1655 void Factory::NewJSArrayStorage(Handle<JSArray> array,
1667 Handle<FixedArrayBase> elms;
1691 Handle<JSGeneratorObject> Factory::NewJSGeneratorObject(
1692 Handle<JSFunction> function) {
1695 Handle<Map> map(function->initial_map());
1704 Handle<JSArrayBuffer> Factory::NewJSArrayBuffer() {
1705 Handle<JSFunction> array_buffer_fun(
1714 Handle<JSDataView> Factory::NewJSDataView() {
1715 Handle<JSFunction> data_view_fun(
1742 Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type) {
1743 Handle<JSFunction> typed_array_fun_handle(GetTypedArrayFun(type, isolate()));
1752 Handle<JSProxy> Factory::NewJSProxy(Handle<Object> handler,
1753 Handle<Object> prototype) {
1757 Handle<Map> map = NewMap(JS_PROXY_TYPE, JSProxy::kSize);
1761 Handle<JSProxy> result = New<JSProxy>(map, NEW_SPACE);
1769 Handle<JSProxy> Factory::NewJSFunctionProxy(Handle<Object> handler,
1770 Handle<Object> call_trap,
1771 Handle<Object> construct_trap,
1772 Handle<Object> prototype) {
1776 Handle<Map> map = NewMap(JS_FUNCTION_PROXY_TYPE, JSFunctionProxy::kSize);
1780 Handle<JSFunctionProxy> result = New<JSFunctionProxy>(map, NEW_SPACE);
1790 void Factory::ReinitializeJSReceiver(Handle<JSReceiver> object,
1797 Handle<Map> map = NewMap(type, size);
1807 Handle<FixedArray> properties = NewFixedArray(prop_size, TENURED);
1814 Handle<String> name = InternalizeStringWithKey(&key);
1824 Handle<JSObject> jsobj = Handle<JSObject>::cast(object);
1832 Handle<JSFunction> js_function = Handle<JSFunction>::cast(object);
1833 Handle<Context> context(isolate()->context()->native_context());
1845 void Factory::ReinitializeJSGlobalProxy(Handle<JSGlobalProxy> object,
1846 Handle<JSFunction> constructor) {
1848 Handle<Map> map(constructor->initial_map(), isolate());
1851 Handle<Object> hash(object->hash(), isolate());
1860 Handle<FixedArray> properties = NewFixedArray(prop_size, TENURED);
1878 void Factory::BecomeJSObject(Handle<JSReceiver> object) {
1883 void Factory::BecomeJSFunction(Handle<JSReceiver> object) {
1888 Handle
1903 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
1904 Handle<String> name,
1907 Handle<Code> code,
1908 Handle<ScopeInfo> scope_info,
1909 Handle<FixedArray> feedback_vector) {
1910 Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(name, code);
1929 Handle<JSMessageObject> Factory::NewJSMessageObject(
1930 Handle<String> type,
1931 Handle<JSArray> arguments,
1934 Handle<Object> script,
1935 Handle<Object> stack_frames) {
1936 Handle<Map> map = message_object_map();
1937 Handle<JSMessageObject> message = New<JSMessageObject>(map, NEW_SPACE);
1951 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
1952 Handle<String> name,
1954 Handle<Map> map = shared_function_info_map();
1955 Handle<SharedFunctionInfo> share = New<SharedFunctionInfo>(map,
1960 Handle<Code> code;
1962 code = handle(isolate()->builtins()->builtin(Builtins::kIllegal));
1996 static inline int NumberCacheHash(Handle<FixedArray> cache,
1997 Handle<Object> number) {
2000 return Handle<Smi>::cast(number)->value() & mask;
2009 Handle<Object> Factory::GetNumberStringCache(Handle<Object> number) {
2015 return Handle<String>(
2022 void Factory::SetNumberStringCache(Handle<Object> number,
2023 Handle<String> string) {
2034 Handle<FixedArray> new_cache = NewFixedArray(full_size, TENURED);
2044 Handle<String> Factory::NumberToString(Handle<Object> number,
2048 Handle<Object> cached = GetNumberStringCache(number);
2049 if (!cached->IsUndefined()) return Handle<String>::cast(cached);
2056 int num = Handle<Smi>::cast(number)->value();
2059 double num = Handle<HeapNumber>::cast(number)->value();
2065 Handle<String> js_string = NewStringFromAsciiChecked(str, TENURED);
2071 Handle<DebugInfo> Factory::NewDebugInfo(Handle<SharedFunctionInfo> shared) {
2073 Handle<Code> code(shared->code());
2077 Handle<Code> original_code(*Factory::CopyCode(code));
2082 Handle<FixedArray> break_points(
2088 Handle<DebugInfo> debug_info =
2089 Handle<DebugInfo>::cast(NewStruct(DEBUG_INFO_TYPE));
2102 Handle<JSObject> Factory::NewArgumentsObject(Handle<Object> callee,
2110 Handle<JSFunction> Factory::CreateApiFunction(
2111 Handle<FunctionTemplateInfo> obj,
2112 Handle<Object> prototype,
2114 Handle<Code> code = isolate()->builtins()->HandleApiCall();
2115 Handle<Code> construct_stub = isolate()->builtins()->JSConstructStubApi();
2117 Handle<JSFunction> result;
2123 Handle<ObjectTemplateInfo> instance_template =
2124 Handle<ObjectTemplateInfo>(
2158 Handle<Object> class_name(obj->class_name(), isolate());
2175 handle(JSObject::cast(result->prototype())),
2183 Handle<Map> map(result->initial_map());
2224 Handle<Object> props_handle(props, isolate());
2232 Handle<Object> props_handle(props, isolate());
2246 Handle<FixedArray> array;
2254 Handle<ObjectTemplateInfo> instance =
2255 Handle<ObjectTemplateInfo>(
2257 Handle<Object> props = Handle<Object>(instance->property_accessors(),
2265 Handle<Object> props = Handle<Object>(obj->property_accessors(),
2271 Handle<Object> parent = Handle<Object>(obj->parent_template(), isolate());
2273 obj = Handle<FunctionTemplateInfo>::cast(parent);
2278 Handle<AccessorInfo> accessor(AccessorInfo::cast(array->get(i)));
2287 Handle<MapCache> Factory::AddToMapCache(Handle<Context> context,
2288 Handle<FixedArray> keys,
2289 Handle<Map> map) {
2290 Handle<MapCache> map_cache = handle(MapCache::cast(context->map_cache()));
2291 Handle<MapCache> result = MapCache::Put(map_cache, keys, map);
2297 Handle<Map> Factory::ObjectLiteralMapFromCache(Handle<Context> context,
2298 Handle<FixedArray> keys) {
2301 Handle<MapCache> new_cache = MapCache::New(isolate(), 24);
2305 Handle<MapCache> cache =
2306 Handle<MapCache>(MapCache::cast(context->map_cache()));
2307 Handle<Object> result = Handle<Object>(cache->Lookup(*keys), isolate());
2308 if (result->IsMap()) return Handle<Map>::cast(result);
2310 Handle<Map> map = Map::Create(
2311 handle(context->object_function()), keys->length());
2317 void Factory::SetRegExpAtomData(Handle<JSRegExp> regexp,
2319 Handle<String> source,
2321 Handle<Object> data) {
2322 Handle<FixedArray> store = NewFixedArray(JSRegExp::kAtomDataSize);
2331 void Factory::SetRegExpIrregexpData(Handle<JSRegExp> regexp,
2333 Handle<String> source,
2336 Handle<FixedArray> store = NewFixedArray(JSRegExp::kIrregexpDataSize);
2354 Handle<FunctionTemplateInfo> desc, Handle<JSObject> instance) {
2357 Handle<Object> instance_template(desc->instance_template(), isolate());
2368 Handle<Object> Factory::GlobalConstantFor(Handle<String> name) {
2372 return Handle<Object>::null();
2376 Handle<Object> Factory::ToBoolean(bool value) {
