Line data Source code
1 : // Copyright 2014 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #ifndef V8_FACTORY_H_
6 : #define V8_FACTORY_H_
7 :
8 : #include "src/feedback-vector.h"
9 : #include "src/globals.h"
10 : #include "src/isolate.h"
11 : #include "src/messages.h"
12 : #include "src/objects/descriptor-array.h"
13 : #include "src/objects/dictionary.h"
14 : #include "src/objects/scope-info.h"
15 :
16 : namespace v8 {
17 : namespace internal {
18 :
19 : class BoilerplateDescription;
20 : class ConstantElementsPair;
21 :
22 : enum FunctionMode {
23 : // With prototype.
24 : FUNCTION_WITH_WRITEABLE_PROTOTYPE,
25 : FUNCTION_WITH_READONLY_PROTOTYPE,
26 : // Without prototype.
27 : FUNCTION_WITHOUT_PROTOTYPE
28 : };
29 :
30 : // Interface for handle based allocation.
31 : class V8_EXPORT_PRIVATE Factory final {
32 : public:
33 : Handle<Oddball> NewOddball(Handle<Map> map, const char* to_string,
34 : Handle<Object> to_number, const char* type_of,
35 : byte kind);
36 :
37 : // Allocates a fixed array initialized with undefined values.
38 : Handle<FixedArray> NewFixedArray(int size,
39 : PretenureFlag pretenure = NOT_TENURED);
40 : // Tries allocating a fixed array initialized with undefined values.
41 : // In case of an allocation failure (OOM) an empty handle is returned.
42 : // The caller has to manually signal an
43 : // v8::internal::Heap::FatalProcessOutOfMemory typically by calling
44 : // NewFixedArray as a fallback.
45 : MUST_USE_RESULT
46 : MaybeHandle<FixedArray> TryNewFixedArray(
47 : int size, PretenureFlag pretenure = NOT_TENURED);
48 :
49 : // Allocate a new fixed array with non-existing entries (the hole).
50 : Handle<FixedArray> NewFixedArrayWithHoles(
51 : int size,
52 : PretenureFlag pretenure = NOT_TENURED);
53 :
54 : // Allocates an uninitialized fixed array. It must be filled by the caller.
55 : Handle<FixedArray> NewUninitializedFixedArray(int size);
56 :
57 : // Allocates a fixed array for name-value pairs of boilerplate properties and
58 : // calculates the number of properties we need to store in the backing store.
59 : Handle<BoilerplateDescription> NewBoilerplateDescription(int boilerplate,
60 : int all_properties,
61 : int index_keys,
62 : bool has_seen_proto);
63 :
64 : // Allocate a new uninitialized fixed double array.
65 : // The function returns a pre-allocated empty fixed array for capacity = 0,
66 : // so the return type must be the general fixed array class.
67 : Handle<FixedArrayBase> NewFixedDoubleArray(
68 : int size,
69 : PretenureFlag pretenure = NOT_TENURED);
70 :
71 : // Allocate a new fixed double array with hole values.
72 : Handle<FixedArrayBase> NewFixedDoubleArrayWithHoles(
73 : int size,
74 : PretenureFlag pretenure = NOT_TENURED);
75 :
76 : Handle<FrameArray> NewFrameArray(int number_of_frames,
77 : PretenureFlag pretenure = NOT_TENURED);
78 :
79 : Handle<OrderedHashSet> NewOrderedHashSet();
80 : Handle<OrderedHashMap> NewOrderedHashMap();
81 :
82 : // Create a new PrototypeInfo struct.
83 : Handle<PrototypeInfo> NewPrototypeInfo();
84 :
85 : // Create a new Tuple2 struct.
86 : Handle<Tuple2> NewTuple2(Handle<Object> value1, Handle<Object> value2);
87 :
88 : // Create a new Tuple3 struct.
89 : Handle<Tuple3> NewTuple3(Handle<Object> value1, Handle<Object> value2,
90 : Handle<Object> value3);
91 :
92 : // Create a new ContextExtension struct.
93 : Handle<ContextExtension> NewContextExtension(Handle<ScopeInfo> scope_info,
94 : Handle<Object> extension);
95 :
96 : // Create a new ConstantElementsPair struct.
97 : Handle<ConstantElementsPair> NewConstantElementsPair(
98 : ElementsKind elements_kind, Handle<FixedArrayBase> constant_values);
99 :
100 : // Create a pre-tenured empty AccessorPair.
101 : Handle<AccessorPair> NewAccessorPair();
102 :
103 : // Create an empty TypeFeedbackInfo.
104 : Handle<TypeFeedbackInfo> NewTypeFeedbackInfo();
105 :
106 : // Finds the internalized copy for string in the string table.
107 : // If not found, a new string is added to the table and returned.
108 : Handle<String> InternalizeUtf8String(Vector<const char> str);
109 8265487 : Handle<String> InternalizeUtf8String(const char* str) {
110 8265487 : return InternalizeUtf8String(CStrVector(str));
111 : }
112 :
113 : Handle<String> InternalizeOneByteString(Vector<const uint8_t> str);
114 : Handle<String> InternalizeOneByteString(
115 : Handle<SeqOneByteString>, int from, int length);
116 :
117 : Handle<String> InternalizeTwoByteString(Vector<const uc16> str);
118 :
119 : template<class StringTableKey>
120 : Handle<String> InternalizeStringWithKey(StringTableKey* key);
121 :
122 : // Internalized strings are created in the old generation (data space).
123 29989523 : Handle<String> InternalizeString(Handle<String> string) {
124 29989523 : if (string->IsInternalizedString()) return string;
125 233426 : return StringTable::LookupString(isolate(), string);
126 : }
127 :
128 296222910 : Handle<Name> InternalizeName(Handle<Name> name) {
129 296222910 : if (name->IsUniqueName()) return name;
130 23147936 : return StringTable::LookupString(isolate(), Handle<String>::cast(name));
131 : }
132 :
133 : // String creation functions. Most of the string creation functions take
134 : // a Heap::PretenureFlag argument to optionally request that they be
135 : // allocated in the old generation. The pretenure flag defaults to
136 : // DONT_TENURE.
137 : //
138 : // Creates a new String object. There are two String encodings: one-byte and
139 : // two-byte. One should choose between the three string factory functions
140 : // based on the encoding of the string buffer that the string is
141 : // initialized from.
142 : // - ...FromOneByte initializes the string from a buffer that is Latin1
143 : // encoded (it does not check that the buffer is Latin1 encoded) and
144 : // the result will be Latin1 encoded.
145 : // - ...FromUtf8 initializes the string from a buffer that is UTF-8
146 : // encoded. If the characters are all ASCII characters, the result
147 : // will be Latin1 encoded, otherwise it will converted to two-byte.
148 : // - ...FromTwoByte initializes the string from a buffer that is two-byte
149 : // encoded. If the characters are all Latin1 characters, the result
150 : // will be converted to Latin1, otherwise it will be left as two-byte.
151 : //
152 : // One-byte strings are pretenured when used as keys in the SourceCodeCache.
153 : MUST_USE_RESULT MaybeHandle<String> NewStringFromOneByte(
154 : Vector<const uint8_t> str, PretenureFlag pretenure = NOT_TENURED);
155 :
156 : template <size_t N>
157 150217 : inline Handle<String> NewStringFromStaticChars(
158 : const char (&str)[N], PretenureFlag pretenure = NOT_TENURED) {
159 : DCHECK(N == StrLength(str) + 1);
160 : return NewStringFromOneByte(STATIC_CHAR_VECTOR(str), pretenure)
161 300434 : .ToHandleChecked();
162 : }
163 :
164 53895680 : inline Handle<String> NewStringFromAsciiChecked(
165 : const char* str,
166 : PretenureFlag pretenure = NOT_TENURED) {
167 : return NewStringFromOneByte(
168 107791364 : OneByteVector(str), pretenure).ToHandleChecked();
169 : }
170 :
171 : // UTF8 strings are pretenured when used for regexp literal patterns and
172 : // flags in the parser.
173 : MUST_USE_RESULT MaybeHandle<String> NewStringFromUtf8(
174 : Vector<const char> str, PretenureFlag pretenure = NOT_TENURED);
175 :
176 : MUST_USE_RESULT MaybeHandle<String> NewStringFromUtf8SubString(
177 : Handle<SeqOneByteString> str, int begin, int end,
178 : PretenureFlag pretenure = NOT_TENURED);
179 :
180 : MUST_USE_RESULT MaybeHandle<String> NewStringFromTwoByte(
181 : Vector<const uc16> str, PretenureFlag pretenure = NOT_TENURED);
182 :
183 : MUST_USE_RESULT MaybeHandle<String> NewStringFromTwoByte(
184 : const ZoneVector<uc16>* str, PretenureFlag pretenure = NOT_TENURED);
185 :
186 : Handle<JSStringIterator> NewJSStringIterator(Handle<String> string);
187 :
188 : // Allocates an internalized string in old space based on the character
189 : // stream.
190 : Handle<String> NewInternalizedStringFromUtf8(Vector<const char> str,
191 : int chars, uint32_t hash_field);
192 :
193 : Handle<String> NewOneByteInternalizedString(Vector<const uint8_t> str,
194 : uint32_t hash_field);
195 :
196 : Handle<String> NewOneByteInternalizedSubString(
197 : Handle<SeqOneByteString> string, int offset, int length,
198 : uint32_t hash_field);
199 :
200 : Handle<String> NewTwoByteInternalizedString(Vector<const uc16> str,
201 : uint32_t hash_field);
202 :
203 : Handle<String> NewInternalizedStringImpl(Handle<String> string, int chars,
204 : uint32_t hash_field);
205 :
206 : // Compute the matching internalized string map for a string if possible.
207 : // Empty handle is returned if string is in new space or not flattened.
208 : MUST_USE_RESULT MaybeHandle<Map> InternalizedStringMapForString(
209 : Handle<String> string);
210 :
211 : // Creates an internalized copy of an external string. |string| must be
212 : // of type StringClass.
213 : template <class StringClass>
214 : Handle<StringClass> InternalizeExternalString(Handle<String> string);
215 :
216 : // Allocates and partially initializes an one-byte or two-byte String. The
217 : // characters of the string are uninitialized. Currently used in regexp code
218 : // only, where they are pretenured.
219 : MUST_USE_RESULT MaybeHandle<SeqOneByteString> NewRawOneByteString(
220 : int length,
221 : PretenureFlag pretenure = NOT_TENURED);
222 : MUST_USE_RESULT MaybeHandle<SeqTwoByteString> NewRawTwoByteString(
223 : int length,
224 : PretenureFlag pretenure = NOT_TENURED);
225 :
226 : // Creates a single character string where the character has given code.
227 : // A cache is used for Latin1 codes.
228 : Handle<String> LookupSingleCharacterStringFromCode(uint32_t code);
229 :
230 : // Create a new cons string object which consists of a pair of strings.
231 : MUST_USE_RESULT MaybeHandle<String> NewConsString(Handle<String> left,
232 : Handle<String> right);
233 :
234 : MUST_USE_RESULT Handle<String> NewConsString(Handle<String> left,
235 : Handle<String> right, int length,
236 : bool one_byte);
237 :
238 : // Create or lookup a single characters tring made up of a utf16 surrogate
239 : // pair.
240 : Handle<String> NewSurrogatePairString(uint16_t lead, uint16_t trail);
241 :
242 : // Create a new string object which holds a proper substring of a string.
243 : Handle<String> NewProperSubString(Handle<String> str,
244 : int begin,
245 : int end);
246 :
247 : // Create a new string object which holds a substring of a string.
248 6811752 : Handle<String> NewSubString(Handle<String> str, int begin, int end) {
249 9259515 : if (begin == 0 && end == str->length()) return str;
250 4771479 : return NewProperSubString(str, begin, end);
251 : }
252 :
253 : // Creates a new external String object. There are two String encodings
254 : // in the system: one-byte and two-byte. Unlike other String types, it does
255 : // not make sense to have a UTF-8 factory function for external strings,
256 : // because we cannot change the underlying buffer. Note that these strings
257 : // are backed by a string resource that resides outside the V8 heap.
258 : MUST_USE_RESULT MaybeHandle<String> NewExternalStringFromOneByte(
259 : const ExternalOneByteString::Resource* resource);
260 : MUST_USE_RESULT MaybeHandle<String> NewExternalStringFromTwoByte(
261 : const ExternalTwoByteString::Resource* resource);
262 : // Create a new external string object for one-byte encoded native script.
263 : // It does not cache the resource data pointer.
264 : Handle<ExternalOneByteString> NewNativeSourceString(
265 : const ExternalOneByteString::Resource* resource);
266 :
267 : // Create a symbol.
268 : Handle<Symbol> NewSymbol();
269 : Handle<Symbol> NewPrivateSymbol();
270 :
271 : // Create a promise.
272 : Handle<JSPromise> NewJSPromise();
273 :
274 : // Create a global (but otherwise uninitialized) context.
275 : Handle<Context> NewNativeContext();
276 :
277 : // Create a script context.
278 : Handle<Context> NewScriptContext(Handle<JSFunction> function,
279 : Handle<ScopeInfo> scope_info);
280 :
281 : // Create an empty script context table.
282 : Handle<ScriptContextTable> NewScriptContextTable();
283 :
284 : // Create a module context.
285 : Handle<Context> NewModuleContext(Handle<Module> module,
286 : Handle<JSFunction> function,
287 : Handle<ScopeInfo> scope_info);
288 :
289 : // Create a function or eval context.
290 : Handle<Context> NewFunctionContext(int length, Handle<JSFunction> function,
291 : ScopeType scope_type);
292 :
293 : // Create a catch context.
294 : Handle<Context> NewCatchContext(Handle<JSFunction> function,
295 : Handle<Context> previous,
296 : Handle<ScopeInfo> scope_info,
297 : Handle<String> name,
298 : Handle<Object> thrown_object);
299 :
300 : // Create a 'with' context.
301 : Handle<Context> NewWithContext(Handle<JSFunction> function,
302 : Handle<Context> previous,
303 : Handle<ScopeInfo> scope_info,
304 : Handle<JSReceiver> extension);
305 :
306 : Handle<Context> NewDebugEvaluateContext(Handle<Context> previous,
307 : Handle<ScopeInfo> scope_info,
308 : Handle<JSReceiver> extension,
309 : Handle<Context> wrapped,
310 : Handle<StringSet> whitelist);
311 :
312 : // Create a block context.
313 : Handle<Context> NewBlockContext(Handle<JSFunction> function,
314 : Handle<Context> previous,
315 : Handle<ScopeInfo> scope_info);
316 :
317 : // Allocate a new struct. The struct is pretenured (allocated directly in
318 : // the old generation).
319 : Handle<Struct> NewStruct(InstanceType type);
320 :
321 : Handle<AliasedArgumentsEntry> NewAliasedArgumentsEntry(
322 : int aliased_context_slot);
323 :
324 : Handle<AccessorInfo> NewAccessorInfo();
325 :
326 : Handle<Script> NewScript(Handle<String> source);
327 :
328 : Handle<BreakPointInfo> NewBreakPointInfo(int source_position);
329 : Handle<StackFrameInfo> NewStackFrameInfo();
330 : Handle<SourcePositionTableWithFrameCache>
331 : NewSourcePositionTableWithFrameCache(
332 : Handle<ByteArray> source_position_table,
333 : Handle<UnseededNumberDictionary> stack_frame_cache);
334 :
335 : // Foreign objects are pretenured when allocated by the bootstrapper.
336 : Handle<Foreign> NewForeign(Address addr,
337 : PretenureFlag pretenure = NOT_TENURED);
338 :
339 : // Allocate a new foreign object. The foreign is pretenured (allocated
340 : // directly in the old generation).
341 : Handle<Foreign> NewForeign(const AccessorDescriptor* foreign);
342 :
343 : Handle<ByteArray> NewByteArray(int length,
344 : PretenureFlag pretenure = NOT_TENURED);
345 :
346 : Handle<BytecodeArray> NewBytecodeArray(int length, const byte* raw_bytecodes,
347 : int frame_size, int parameter_count,
348 : Handle<FixedArray> constant_pool);
349 :
350 : Handle<FixedTypedArrayBase> NewFixedTypedArrayWithExternalPointer(
351 : int length, ExternalArrayType array_type, void* external_pointer,
352 : PretenureFlag pretenure = NOT_TENURED);
353 :
354 : Handle<FixedTypedArrayBase> NewFixedTypedArray(
355 : int length, ExternalArrayType array_type, bool initialize,
356 : PretenureFlag pretenure = NOT_TENURED);
357 :
358 : Handle<Cell> NewCell(Handle<Object> value);
359 :
360 : Handle<PropertyCell> NewPropertyCell();
361 :
362 : Handle<WeakCell> NewWeakCell(Handle<HeapObject> value);
363 :
364 : Handle<Cell> NewNoClosuresCell(Handle<Object> value);
365 : Handle<Cell> NewOneClosureCell(Handle<Object> value);
366 : Handle<Cell> NewManyClosuresCell(Handle<Object> value);
367 :
368 : Handle<TransitionArray> NewTransitionArray(int capacity);
369 :
370 : // Allocate a tenured AllocationSite. It's payload is null.
371 : Handle<AllocationSite> NewAllocationSite();
372 :
373 : Handle<Map> NewMap(
374 : InstanceType type,
375 : int instance_size,
376 : ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND);
377 :
378 : Handle<HeapObject> NewFillerObject(int size,
379 : bool double_align,
380 : AllocationSpace space);
381 :
382 : Handle<JSObject> NewFunctionPrototype(Handle<JSFunction> function);
383 :
384 : Handle<JSObject> CopyJSObject(Handle<JSObject> object);
385 :
386 : Handle<JSObject> CopyJSObjectWithAllocationSite(Handle<JSObject> object,
387 : Handle<AllocationSite> site);
388 :
389 : Handle<FixedArray> CopyFixedArrayWithMap(Handle<FixedArray> array,
390 : Handle<Map> map);
391 :
392 : Handle<FixedArray> CopyFixedArrayAndGrow(
393 : Handle<FixedArray> array, int grow_by,
394 : PretenureFlag pretenure = NOT_TENURED);
395 :
396 : Handle<FixedArray> CopyFixedArrayUpTo(Handle<FixedArray> array, int new_len,
397 : PretenureFlag pretenure = NOT_TENURED);
398 :
399 : Handle<FixedArray> CopyFixedArray(Handle<FixedArray> array);
400 :
401 : // This method expects a COW array in new space, and creates a copy
402 : // of it in old space.
403 : Handle<FixedArray> CopyAndTenureFixedCOWArray(Handle<FixedArray> array);
404 :
405 : Handle<FixedDoubleArray> CopyFixedDoubleArray(
406 : Handle<FixedDoubleArray> array);
407 :
408 : // Numbers (e.g. literals) are pretenured by the parser.
409 : // The return value may be a smi or a heap number.
410 : Handle<Object> NewNumber(double value,
411 : PretenureFlag pretenure = NOT_TENURED);
412 :
413 : Handle<Object> NewNumberFromInt(int32_t value,
414 : PretenureFlag pretenure = NOT_TENURED);
415 : Handle<Object> NewNumberFromUint(uint32_t value,
416 : PretenureFlag pretenure = NOT_TENURED);
417 135073 : Handle<Object> NewNumberFromSize(size_t value,
418 : PretenureFlag pretenure = NOT_TENURED) {
419 : // We can't use Smi::IsValid() here because that operates on a signed
420 : // intptr_t, and casting from size_t could create a bogus sign bit.
421 135073 : if (value <= static_cast<size_t>(Smi::kMaxValue)) {
422 134979 : return Handle<Object>(Smi::FromIntptr(static_cast<intptr_t>(value)),
423 134979 : isolate());
424 : }
425 94 : return NewNumber(static_cast<double>(value), pretenure);
426 : }
427 42135 : Handle<Object> NewNumberFromInt64(int64_t value,
428 : PretenureFlag pretenure = NOT_TENURED) {
429 42051 : if (value <= std::numeric_limits<int32_t>::max() &&
430 42135 : value >= std::numeric_limits<int32_t>::min() &&
431 : Smi::IsValid(static_cast<int32_t>(value))) {
432 42051 : return Handle<Object>(Smi::FromInt(static_cast<int32_t>(value)),
433 42051 : isolate());
434 : }
435 84 : return NewNumber(static_cast<double>(value), pretenure);
436 : }
437 30133 : Handle<HeapNumber> NewHeapNumber(double value, MutableMode mode = IMMUTABLE,
438 : PretenureFlag pretenure = NOT_TENURED) {
439 36506636 : Handle<HeapNumber> heap_number = NewHeapNumber(mode, pretenure);
440 : heap_number->set_value(value);
441 30133 : return heap_number;
442 : }
443 : Handle<HeapNumber> NewHeapNumberFromBits(
444 : uint64_t bits, MutableMode mode = IMMUTABLE,
445 : PretenureFlag pretenure = NOT_TENURED) {
446 49544 : Handle<HeapNumber> heap_number = NewHeapNumber(mode, pretenure);
447 : heap_number->set_value_as_bits(bits);
448 : return heap_number;
449 : }
450 : // Creates mutable heap number object with value field set to hole NaN.
451 : Handle<HeapNumber> NewMutableHeapNumber(
452 : PretenureFlag pretenure = NOT_TENURED) {
453 : return NewHeapNumberFromBits(kHoleNanInt64, MUTABLE, pretenure);
454 : }
455 :
456 : // Creates heap number object with not yet set value field.
457 : Handle<HeapNumber> NewHeapNumber(MutableMode mode,
458 : PretenureFlag pretenure = NOT_TENURED);
459 :
460 : Handle<JSWeakMap> NewJSWeakMap();
461 :
462 : Handle<JSObject> NewArgumentsObject(Handle<JSFunction> callee, int length);
463 :
464 : // JS objects are pretenured when allocated by the bootstrapper and
465 : // runtime.
466 : Handle<JSObject> NewJSObject(Handle<JSFunction> constructor,
467 : PretenureFlag pretenure = NOT_TENURED);
468 : // JSObject without a prototype.
469 : Handle<JSObject> NewJSObjectWithNullProto(
470 : PretenureFlag pretenure = NOT_TENURED);
471 :
472 : // Global objects are pretenured and initialized based on a constructor.
473 : Handle<JSGlobalObject> NewJSGlobalObject(Handle<JSFunction> constructor);
474 :
475 : // JS objects are pretenured when allocated by the bootstrapper and
476 : // runtime.
477 : Handle<JSObject> NewJSObjectFromMap(
478 : Handle<Map> map,
479 : PretenureFlag pretenure = NOT_TENURED,
480 : Handle<AllocationSite> allocation_site = Handle<AllocationSite>::null());
481 :
482 : // JS arrays are pretenured when allocated by the parser.
483 :
484 : // Create a JSArray with a specified length and elements initialized
485 : // according to the specified mode.
486 : Handle<JSArray> NewJSArray(
487 : ElementsKind elements_kind, int length, int capacity,
488 : ArrayStorageAllocationMode mode = DONT_INITIALIZE_ARRAY_ELEMENTS,
489 : PretenureFlag pretenure = NOT_TENURED);
490 :
491 1960537 : Handle<JSArray> NewJSArray(
492 : int capacity, ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND,
493 : PretenureFlag pretenure = NOT_TENURED) {
494 1960537 : if (capacity != 0) {
495 : elements_kind = GetHoleyElementsKind(elements_kind);
496 : }
497 : return NewJSArray(elements_kind, 0, capacity,
498 1960537 : INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE, pretenure);
499 : }
500 :
501 : // Create a JSArray with the given elements.
502 : Handle<JSArray> NewJSArrayWithElements(Handle<FixedArrayBase> elements,
503 : ElementsKind elements_kind, int length,
504 : PretenureFlag pretenure = NOT_TENURED);
505 :
506 6148495 : Handle<JSArray> NewJSArrayWithElements(
507 : Handle<FixedArrayBase> elements,
508 : ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND,
509 : PretenureFlag pretenure = NOT_TENURED) {
510 : return NewJSArrayWithElements(elements, elements_kind, elements->length(),
511 18251388 : pretenure);
512 : }
513 :
514 : void NewJSArrayStorage(
515 : Handle<JSArray> array,
516 : int length,
517 : int capacity,
518 : ArrayStorageAllocationMode mode = DONT_INITIALIZE_ARRAY_ELEMENTS);
519 :
520 : Handle<JSGeneratorObject> NewJSGeneratorObject(Handle<JSFunction> function);
521 :
522 : Handle<JSModuleNamespace> NewJSModuleNamespace();
523 :
524 : Handle<Module> NewModule(Handle<SharedFunctionInfo> code);
525 :
526 : Handle<JSArrayBuffer> NewJSArrayBuffer(
527 : SharedFlag shared = SharedFlag::kNotShared,
528 : PretenureFlag pretenure = NOT_TENURED);
529 :
530 : ExternalArrayType GetArrayTypeFromElementsKind(ElementsKind kind);
531 : size_t GetExternalArrayElementSize(ExternalArrayType type);
532 :
533 : Handle<JSTypedArray> NewJSTypedArray(ExternalArrayType type,
534 : PretenureFlag pretenure = NOT_TENURED);
535 :
536 : Handle<JSTypedArray> NewJSTypedArray(ElementsKind elements_kind,
537 : PretenureFlag pretenure = NOT_TENURED);
538 :
539 : // Creates a new JSTypedArray with the specified buffer.
540 : Handle<JSTypedArray> NewJSTypedArray(ExternalArrayType type,
541 : Handle<JSArrayBuffer> buffer,
542 : size_t byte_offset, size_t length,
543 : PretenureFlag pretenure = NOT_TENURED);
544 :
545 : // Creates a new on-heap JSTypedArray.
546 : Handle<JSTypedArray> NewJSTypedArray(ElementsKind elements_kind,
547 : size_t number_of_elements,
548 : PretenureFlag pretenure = NOT_TENURED);
549 :
550 : Handle<JSDataView> NewJSDataView();
551 : Handle<JSDataView> NewJSDataView(Handle<JSArrayBuffer> buffer,
552 : size_t byte_offset, size_t byte_length);
553 :
554 : Handle<JSIteratorResult> NewJSIteratorResult(Handle<Object> value, bool done);
555 : Handle<JSAsyncFromSyncIterator> NewJSAsyncFromSyncIterator(
556 : Handle<JSReceiver> sync_iterator);
557 :
558 : Handle<JSMap> NewJSMap();
559 : Handle<JSSet> NewJSSet();
560 :
561 : // TODO(aandrey): Maybe these should take table, index and kind arguments.
562 : Handle<JSMapIterator> NewJSMapIterator();
563 : Handle<JSSetIterator> NewJSSetIterator();
564 :
565 : // Allocates a bound function.
566 : MaybeHandle<JSBoundFunction> NewJSBoundFunction(
567 : Handle<JSReceiver> target_function, Handle<Object> bound_this,
568 : Vector<Handle<Object>> bound_args);
569 :
570 : // Allocates a Harmony proxy.
571 : Handle<JSProxy> NewJSProxy(Handle<JSReceiver> target,
572 : Handle<JSReceiver> handler);
573 :
574 : // Reinitialize an JSGlobalProxy based on a constructor. The object
575 : // must have the same size as objects allocated using the
576 : // constructor. The object is reinitialized and behaves as an
577 : // object that has been freshly allocated using the constructor.
578 : void ReinitializeJSGlobalProxy(Handle<JSGlobalProxy> global,
579 : Handle<JSFunction> constructor);
580 :
581 : Handle<JSGlobalProxy> NewUninitializedJSGlobalProxy(int size);
582 :
583 : Handle<JSFunction> NewFunction(Handle<Map> map,
584 : Handle<SharedFunctionInfo> info,
585 : Handle<Object> context_or_undefined,
586 : PretenureFlag pretenure = TENURED);
587 : Handle<JSFunction> NewFunction(Handle<String> name, Handle<Code> code,
588 : Handle<Object> prototype,
589 : bool is_strict = false);
590 : Handle<JSFunction> NewFunction(Handle<String> name);
591 : Handle<JSFunction> NewFunctionWithoutPrototype(Handle<String> name,
592 : Handle<Code> code,
593 : bool is_strict = false);
594 :
595 : Handle<JSFunction> NewFunctionFromSharedFunctionInfo(
596 : Handle<Map> initial_map, Handle<SharedFunctionInfo> function_info,
597 : Handle<Object> context_or_undefined, Handle<Cell> vector,
598 : PretenureFlag pretenure = TENURED);
599 :
600 : Handle<JSFunction> NewFunctionFromSharedFunctionInfo(
601 : Handle<SharedFunctionInfo> function_info, Handle<Context> context,
602 : Handle<Cell> vector, PretenureFlag pretenure = TENURED);
603 :
604 : Handle<JSFunction> NewFunctionFromSharedFunctionInfo(
605 : Handle<Map> initial_map, Handle<SharedFunctionInfo> function_info,
606 : Handle<Object> context_or_undefined, PretenureFlag pretenure = TENURED);
607 :
608 : Handle<JSFunction> NewFunctionFromSharedFunctionInfo(
609 : Handle<SharedFunctionInfo> function_info, Handle<Context> context,
610 : PretenureFlag pretenure = TENURED);
611 :
612 : Handle<JSFunction> NewFunction(Handle<String> name, Handle<Code> code,
613 : Handle<Object> prototype, InstanceType type,
614 : int instance_size,
615 : bool is_strict = false);
616 : Handle<JSFunction> NewFunction(Handle<String> name,
617 : Handle<Code> code,
618 : InstanceType type,
619 : int instance_size);
620 : Handle<JSFunction> NewFunction(Handle<Map> map, Handle<String> name,
621 : MaybeHandle<Code> maybe_code);
622 :
623 : // Create a serialized scope info.
624 : Handle<ScopeInfo> NewScopeInfo(int length);
625 :
626 : Handle<ModuleInfoEntry> NewModuleInfoEntry();
627 : Handle<ModuleInfo> NewModuleInfo();
628 :
629 : // Create an External object for V8's external API.
630 : Handle<JSObject> NewExternal(void* value);
631 :
632 : // The reference to the Code object is stored in self_reference.
633 : // This allows generated code to reference its own Code object
634 : // by containing this handle.
635 : Handle<Code> NewCode(const CodeDesc& desc,
636 : Code::Flags flags,
637 : Handle<Object> self_reference,
638 : bool immovable = false,
639 : bool crankshafted = false,
640 : int prologue_offset = Code::kPrologueOffsetNotSet,
641 : bool is_debug = false);
642 :
643 : Handle<Code> CopyCode(Handle<Code> code);
644 :
645 : Handle<BytecodeArray> CopyBytecodeArray(Handle<BytecodeArray>);
646 :
647 : // Interface for creating error objects.
648 : Handle<Object> NewError(Handle<JSFunction> constructor,
649 : Handle<String> message);
650 :
651 : Handle<Object> NewInvalidStringLengthError();
652 :
653 8212 : Handle<Object> NewURIError() {
654 : return NewError(isolate()->uri_error_function(),
655 8212 : MessageTemplate::kURIMalformed);
656 : }
657 :
658 : Handle<Object> NewError(Handle<JSFunction> constructor,
659 : MessageTemplate::Template template_index,
660 : Handle<Object> arg0 = Handle<Object>(),
661 : Handle<Object> arg1 = Handle<Object>(),
662 : Handle<Object> arg2 = Handle<Object>());
663 :
664 : #define DECLARE_ERROR(NAME) \
665 : Handle<Object> New##NAME(MessageTemplate::Template template_index, \
666 : Handle<Object> arg0 = Handle<Object>(), \
667 : Handle<Object> arg1 = Handle<Object>(), \
668 : Handle<Object> arg2 = Handle<Object>());
669 : DECLARE_ERROR(Error)
670 : DECLARE_ERROR(EvalError)
671 : DECLARE_ERROR(RangeError)
672 : DECLARE_ERROR(ReferenceError)
673 : DECLARE_ERROR(SyntaxError)
674 : DECLARE_ERROR(TypeError)
675 : DECLARE_ERROR(WasmCompileError)
676 : DECLARE_ERROR(WasmLinkError)
677 : DECLARE_ERROR(WasmRuntimeError)
678 : #undef DECLARE_ERROR
679 :
680 : Handle<String> NumberToString(Handle<Object> number,
681 : bool check_number_string_cache = true);
682 :
683 2786690 : Handle<String> Uint32ToString(uint32_t value) {
684 2786690 : Handle<String> result = NumberToString(NewNumberFromUint(value));
685 :
686 2786690 : if (result->length() <= String::kMaxArrayIndexSize) {
687 : uint32_t field =
688 2303138 : StringHasher::MakeArrayIndexHash(value, result->length());
689 : result->set_hash_field(field);
690 : }
691 2786690 : return result;
692 : }
693 :
694 : Handle<JSFunction> InstallMembers(Handle<JSFunction> function);
695 :
696 : #define ROOT_ACCESSOR(type, name, camel_name) \
697 : inline Handle<type> name() { \
698 : return Handle<type>(bit_cast<type**>( \
699 : &isolate()->heap()->roots_[Heap::k##camel_name##RootIndex])); \
700 : }
701 1000049996 : ROOT_LIST(ROOT_ACCESSOR)
702 : #undef ROOT_ACCESSOR
703 :
704 : #define STRUCT_MAP_ACCESSOR(NAME, Name, name) \
705 : inline Handle<Map> name##_map() { \
706 : return Handle<Map>(bit_cast<Map**>( \
707 : &isolate()->heap()->roots_[Heap::k##Name##MapRootIndex])); \
708 : }
709 1306214 : STRUCT_LIST(STRUCT_MAP_ACCESSOR)
710 : #undef STRUCT_MAP_ACCESSOR
711 :
712 : #define STRING_ACCESSOR(name, str) \
713 : inline Handle<String> name() { \
714 : return Handle<String>(bit_cast<String**>( \
715 : &isolate()->heap()->roots_[Heap::k##name##RootIndex])); \
716 : }
717 77346828 : INTERNALIZED_STRING_LIST(STRING_ACCESSOR)
718 : #undef STRING_ACCESSOR
719 :
720 : #define SYMBOL_ACCESSOR(name) \
721 : inline Handle<Symbol> name() { \
722 : return Handle<Symbol>(bit_cast<Symbol**>( \
723 : &isolate()->heap()->roots_[Heap::k##name##RootIndex])); \
724 : }
725 58763868 : PRIVATE_SYMBOL_LIST(SYMBOL_ACCESSOR)
726 : #undef SYMBOL_ACCESSOR
727 :
728 : #define SYMBOL_ACCESSOR(name, description) \
729 : inline Handle<Symbol> name() { \
730 : return Handle<Symbol>(bit_cast<Symbol**>( \
731 : &isolate()->heap()->roots_[Heap::k##name##RootIndex])); \
732 : }
733 11111237 : PUBLIC_SYMBOL_LIST(SYMBOL_ACCESSOR)
734 4556457 : WELL_KNOWN_SYMBOL_LIST(SYMBOL_ACCESSOR)
735 : #undef SYMBOL_ACCESSOR
736 :
737 : // Allocates a new SharedFunctionInfo object.
738 : Handle<SharedFunctionInfo> NewSharedFunctionInfo(
739 : Handle<String> name, FunctionKind kind, Handle<Code> code,
740 : Handle<ScopeInfo> scope_info);
741 : Handle<SharedFunctionInfo> NewSharedFunctionInfo(Handle<String> name,
742 : MaybeHandle<Code> code,
743 : bool is_constructor);
744 :
745 : Handle<SharedFunctionInfo> NewSharedFunctionInfoForLiteral(
746 : FunctionLiteral* literal, Handle<Script> script);
747 :
748 : static bool IsFunctionModeWithPrototype(FunctionMode function_mode) {
749 : return (function_mode == FUNCTION_WITH_WRITEABLE_PROTOTYPE ||
750 : function_mode == FUNCTION_WITH_READONLY_PROTOTYPE);
751 : }
752 :
753 : Handle<Map> CreateSloppyFunctionMap(FunctionMode function_mode);
754 :
755 : Handle<Map> CreateStrictFunctionMap(FunctionMode function_mode,
756 : Handle<JSFunction> empty_function);
757 :
758 : Handle<Map> CreateClassFunctionMap(Handle<JSFunction> empty_function);
759 :
760 : // Allocates a new JSMessageObject object.
761 : Handle<JSMessageObject> NewJSMessageObject(MessageTemplate::Template message,
762 : Handle<Object> argument,
763 : int start_position,
764 : int end_position,
765 : Handle<Object> script,
766 : Handle<Object> stack_frames);
767 :
768 : Handle<DebugInfo> NewDebugInfo(Handle<SharedFunctionInfo> shared);
769 :
770 : // Return a map for given number of properties using the map cache in the
771 : // native context.
772 : Handle<Map> ObjectLiteralMapFromCache(Handle<Context> context,
773 : int number_of_properties,
774 : bool* is_result_from_cache);
775 :
776 : Handle<RegExpMatchInfo> NewRegExpMatchInfo();
777 :
778 : // Creates a new FixedArray that holds the data associated with the
779 : // atom regexp and stores it in the regexp.
780 : void SetRegExpAtomData(Handle<JSRegExp> regexp,
781 : JSRegExp::Type type,
782 : Handle<String> source,
783 : JSRegExp::Flags flags,
784 : Handle<Object> match_pattern);
785 :
786 : // Creates a new FixedArray that holds the data associated with the
787 : // irregexp regexp and stores it in the regexp.
788 : void SetRegExpIrregexpData(Handle<JSRegExp> regexp,
789 : JSRegExp::Type type,
790 : Handle<String> source,
791 : JSRegExp::Flags flags,
792 : int capture_count);
793 :
794 : // Returns the value for a known global constant (a property of the global
795 : // object which is neither configurable nor writable) like 'undefined'.
796 : // Returns a null handle when the given name is unknown.
797 : Handle<Object> GlobalConstantFor(Handle<Name> name);
798 :
799 : // Converts the given boolean condition to JavaScript boolean value.
800 : Handle<Object> ToBoolean(bool value);
801 :
802 : // Converts the given ToPrimitive hint to it's string representation.
803 : Handle<String> ToPrimitiveHintString(ToPrimitiveHint hint);
804 :
805 : private:
806 : Isolate* isolate() { return reinterpret_cast<Isolate*>(this); }
807 :
808 : // Creates a heap object based on the map. The fields of the heap object are
809 : // not initialized by New<>() functions. It's the responsibility of the caller
810 : // to do that.
811 : template<typename T>
812 : Handle<T> New(Handle<Map> map, AllocationSpace space);
813 :
814 : template<typename T>
815 : Handle<T> New(Handle<Map> map,
816 : AllocationSpace space,
817 : Handle<AllocationSite> allocation_site);
818 :
819 : MaybeHandle<String> NewStringFromTwoByte(const uc16* string, int length,
820 : PretenureFlag pretenure);
821 :
822 : // Creates a code object that is not yet fully initialized yet.
823 : inline Handle<Code> NewCodeRaw(int object_size, bool immovable);
824 :
825 : // Attempt to find the number in a small cache. If we finds it, return
826 : // the string representation of the number. Otherwise return undefined.
827 : Handle<Object> GetNumberStringCache(Handle<Object> number);
828 :
829 : // Update the cache with a new number-string pair.
830 : void SetNumberStringCache(Handle<Object> number, Handle<String> string);
831 :
832 : // Create a JSArray with no elements and no length.
833 : Handle<JSArray> NewJSArray(ElementsKind elements_kind,
834 : PretenureFlag pretenure = NOT_TENURED);
835 :
836 : void SetFunctionInstanceDescriptor(Handle<Map> map,
837 : FunctionMode function_mode);
838 :
839 : void SetStrictFunctionInstanceDescriptor(Handle<Map> map,
840 : FunctionMode function_mode);
841 :
842 : void SetClassFunctionInstanceDescriptor(Handle<Map> map);
843 : };
844 :
845 : } // namespace internal
846 : } // namespace v8
847 :
848 : #endif // V8_FACTORY_H_
|
