Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 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. |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 4 | |
| 5 | #ifndef V8_FACTORY_H_ |
| 6 | #define V8_FACTORY_H_ |
| 7 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 8 | #include "src/isolate.h" |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 9 | #include "src/messages.h" |
| 10 | #include "src/type-feedback-vector.h" |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 11 | |
| 12 | namespace v8 { |
| 13 | namespace internal { |
| 14 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 15 | // Interface for handle based allocation. |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 16 | class Factory final { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 17 | public: |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 18 | Handle<Oddball> NewOddball(Handle<Map> map, const char* to_string, |
| 19 | Handle<Object> to_number, const char* type_of, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 20 | byte kind); |
| 21 | |
| 22 | // Allocates a fixed array initialized with undefined values. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 23 | Handle<FixedArray> NewFixedArray( |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 24 | int size, |
| 25 | PretenureFlag pretenure = NOT_TENURED); |
| 26 | |
| 27 | // Allocate a new fixed array with non-existing entries (the hole). |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 28 | Handle<FixedArray> NewFixedArrayWithHoles( |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 29 | int size, |
| 30 | PretenureFlag pretenure = NOT_TENURED); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 31 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 32 | // Allocates an uninitialized fixed array. It must be filled by the caller. |
| 33 | Handle<FixedArray> NewUninitializedFixedArray(int size); |
| 34 | |
Ben Murdoch | 3fb3ca8 | 2011-12-02 17:19:32 +0000 | [diff] [blame] | 35 | // Allocate a new uninitialized fixed double array. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 36 | // The function returns a pre-allocated empty fixed array for capacity = 0, |
| 37 | // so the return type must be the general fixed array class. |
| 38 | Handle<FixedArrayBase> NewFixedDoubleArray( |
Ben Murdoch | 3fb3ca8 | 2011-12-02 17:19:32 +0000 | [diff] [blame] | 39 | int size, |
| 40 | PretenureFlag pretenure = NOT_TENURED); |
| 41 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 42 | // Allocate a new fixed double array with hole values. |
| 43 | Handle<FixedArrayBase> NewFixedDoubleArrayWithHoles( |
| 44 | int size, |
| 45 | PretenureFlag pretenure = NOT_TENURED); |
Ben Murdoch | c7cc028 | 2012-03-05 14:35:55 +0000 | [diff] [blame] | 46 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 47 | Handle<OrderedHashSet> NewOrderedHashSet(); |
| 48 | Handle<OrderedHashMap> NewOrderedHashMap(); |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 49 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 50 | // Create a new boxed value. |
| 51 | Handle<Box> NewBox(Handle<Object> value); |
Ben Murdoch | 69a99ed | 2011-11-30 16:03:39 +0000 | [diff] [blame] | 52 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 53 | // Create a new PrototypeInfo struct. |
| 54 | Handle<PrototypeInfo> NewPrototypeInfo(); |
| 55 | |
| 56 | // Create a new SloppyBlockWithEvalContextExtension struct. |
| 57 | Handle<SloppyBlockWithEvalContextExtension> |
| 58 | NewSloppyBlockWithEvalContextExtension(Handle<ScopeInfo> scope_info, |
| 59 | Handle<JSObject> extension); |
| 60 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 61 | // Create a pre-tenured empty AccessorPair. |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 62 | Handle<AccessorPair> NewAccessorPair(); |
| 63 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 64 | // Create an empty TypeFeedbackInfo. |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 65 | Handle<TypeFeedbackInfo> NewTypeFeedbackInfo(); |
Ben Murdoch | 5d4cdbf | 2012-04-11 10:23:59 +0100 | [diff] [blame] | 66 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 67 | // Finds the internalized copy for string in the string table. |
| 68 | // If not found, a new string is added to the table and returned. |
| 69 | Handle<String> InternalizeUtf8String(Vector<const char> str); |
| 70 | Handle<String> InternalizeUtf8String(const char* str) { |
| 71 | return InternalizeUtf8String(CStrVector(str)); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 72 | } |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame^] | 73 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 74 | Handle<String> InternalizeOneByteString(Vector<const uint8_t> str); |
| 75 | Handle<String> InternalizeOneByteString( |
| 76 | Handle<SeqOneByteString>, int from, int length); |
| 77 | |
| 78 | Handle<String> InternalizeTwoByteString(Vector<const uc16> str); |
| 79 | |
| 80 | template<class StringTableKey> |
| 81 | Handle<String> InternalizeStringWithKey(StringTableKey* key); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 82 | |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame^] | 83 | // Internalized strings are created in the old generation (data space). |
| 84 | Handle<String> InternalizeString(Handle<String> string) { |
| 85 | if (string->IsInternalizedString()) return string; |
| 86 | return StringTable::LookupString(isolate(), string); |
| 87 | } |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 88 | |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame^] | 89 | Handle<Name> InternalizeName(Handle<Name> name) { |
| 90 | if (name->IsUniqueName()) return name; |
| 91 | return StringTable::LookupString(isolate(), Handle<String>::cast(name)); |
| 92 | } |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 93 | |
| 94 | // String creation functions. Most of the string creation functions take |
| 95 | // a Heap::PretenureFlag argument to optionally request that they be |
| 96 | // allocated in the old generation. The pretenure flag defaults to |
| 97 | // DONT_TENURE. |
| 98 | // |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 99 | // Creates a new String object. There are two String encodings: one-byte and |
| 100 | // two-byte. One should choose between the three string factory functions |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 101 | // based on the encoding of the string buffer that the string is |
| 102 | // initialized from. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 103 | // - ...FromOneByte initializes the string from a buffer that is Latin1 |
| 104 | // encoded (it does not check that the buffer is Latin1 encoded) and |
| 105 | // the result will be Latin1 encoded. |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 106 | // - ...FromUtf8 initializes the string from a buffer that is UTF-8 |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 107 | // encoded. If the characters are all ASCII characters, the result |
| 108 | // will be Latin1 encoded, otherwise it will converted to two-byte. |
| 109 | // - ...FromTwoByte initializes the string from a buffer that is two-byte |
| 110 | // encoded. If the characters are all Latin1 characters, the result |
| 111 | // will be converted to Latin1, otherwise it will be left as two-byte. |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 112 | // |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 113 | // One-byte strings are pretenured when used as keys in the SourceCodeCache. |
| 114 | MUST_USE_RESULT MaybeHandle<String> NewStringFromOneByte( |
| 115 | Vector<const uint8_t> str, |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 116 | PretenureFlag pretenure = NOT_TENURED); |
| 117 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 118 | template <size_t N> |
| 119 | inline Handle<String> NewStringFromStaticChars( |
| 120 | const char (&str)[N], PretenureFlag pretenure = NOT_TENURED) { |
| 121 | DCHECK(N == StrLength(str) + 1); |
| 122 | return NewStringFromOneByte(STATIC_CHAR_VECTOR(str), pretenure) |
| 123 | .ToHandleChecked(); |
| 124 | } |
| 125 | |
| 126 | inline Handle<String> NewStringFromAsciiChecked( |
| 127 | const char* str, |
| 128 | PretenureFlag pretenure = NOT_TENURED) { |
| 129 | return NewStringFromOneByte( |
| 130 | OneByteVector(str), pretenure).ToHandleChecked(); |
| 131 | } |
| 132 | |
| 133 | |
| 134 | // Allocates and fully initializes a String. There are two String encodings: |
| 135 | // one-byte and two-byte. One should choose between the threestring |
| 136 | // allocation functions based on the encoding of the string buffer used to |
| 137 | // initialized the string. |
| 138 | // - ...FromOneByte initializes the string from a buffer that is Latin1 |
| 139 | // encoded (it does not check that the buffer is Latin1 encoded) and the |
| 140 | // result will be Latin1 encoded. |
| 141 | // - ...FromUTF8 initializes the string from a buffer that is UTF-8 |
| 142 | // encoded. If the characters are all ASCII characters, the result |
| 143 | // will be Latin1 encoded, otherwise it will converted to two-byte. |
| 144 | // - ...FromTwoByte initializes the string from a buffer that is two-byte |
| 145 | // encoded. If the characters are all Latin1 characters, the |
| 146 | // result will be converted to Latin1, otherwise it will be left as |
| 147 | // two-byte. |
| 148 | |
| 149 | // TODO(dcarney): remove this function. |
| 150 | MUST_USE_RESULT inline MaybeHandle<String> NewStringFromAscii( |
| 151 | Vector<const char> str, |
| 152 | PretenureFlag pretenure = NOT_TENURED) { |
| 153 | return NewStringFromOneByte(Vector<const uint8_t>::cast(str), pretenure); |
| 154 | } |
| 155 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 156 | // UTF8 strings are pretenured when used for regexp literal patterns and |
| 157 | // flags in the parser. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 158 | MUST_USE_RESULT MaybeHandle<String> NewStringFromUtf8( |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 159 | Vector<const char> str, |
| 160 | PretenureFlag pretenure = NOT_TENURED); |
| 161 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 162 | MUST_USE_RESULT MaybeHandle<String> NewStringFromTwoByte( |
Leon Clarke | ac95265 | 2010-07-15 11:15:24 +0100 | [diff] [blame] | 163 | Vector<const uc16> str, |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 164 | PretenureFlag pretenure = NOT_TENURED); |
| 165 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 166 | // Allocates an internalized string in old space based on the character |
| 167 | // stream. |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 168 | Handle<String> NewInternalizedStringFromUtf8(Vector<const char> str, |
| 169 | int chars, uint32_t hash_field); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 170 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 171 | Handle<String> NewOneByteInternalizedString(Vector<const uint8_t> str, |
| 172 | uint32_t hash_field); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 173 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 174 | Handle<String> NewOneByteInternalizedSubString( |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 175 | Handle<SeqOneByteString> string, int offset, int length, |
| 176 | uint32_t hash_field); |
| 177 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 178 | Handle<String> NewTwoByteInternalizedString(Vector<const uc16> str, |
| 179 | uint32_t hash_field); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 180 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 181 | Handle<String> NewInternalizedStringImpl(Handle<String> string, int chars, |
| 182 | uint32_t hash_field); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 183 | |
| 184 | // Compute the matching internalized string map for a string if possible. |
| 185 | // Empty handle is returned if string is in new space or not flattened. |
| 186 | MUST_USE_RESULT MaybeHandle<Map> InternalizedStringMapForString( |
| 187 | Handle<String> string); |
| 188 | |
| 189 | // Allocates and partially initializes an one-byte or two-byte String. The |
Leon Clarke | ac95265 | 2010-07-15 11:15:24 +0100 | [diff] [blame] | 190 | // characters of the string are uninitialized. Currently used in regexp code |
| 191 | // only, where they are pretenured. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 192 | MUST_USE_RESULT MaybeHandle<SeqOneByteString> NewRawOneByteString( |
Leon Clarke | ac95265 | 2010-07-15 11:15:24 +0100 | [diff] [blame] | 193 | int length, |
| 194 | PretenureFlag pretenure = NOT_TENURED); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 195 | MUST_USE_RESULT MaybeHandle<SeqTwoByteString> NewRawTwoByteString( |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 196 | int length, |
| 197 | PretenureFlag pretenure = NOT_TENURED); |
| 198 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 199 | // Creates a single character string where the character has given code. |
| 200 | // A cache is used for Latin1 codes. |
| 201 | Handle<String> LookupSingleCharacterStringFromCode(uint32_t code); |
| 202 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 203 | // Create a new cons string object which consists of a pair of strings. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 204 | MUST_USE_RESULT MaybeHandle<String> NewConsString(Handle<String> left, |
| 205 | Handle<String> right); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 206 | |
Ben Murdoch | 3fb3ca8 | 2011-12-02 17:19:32 +0000 | [diff] [blame] | 207 | // Create a new string object which holds a proper substring of a string. |
| 208 | Handle<String> NewProperSubString(Handle<String> str, |
| 209 | int begin, |
| 210 | int end); |
| 211 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 212 | // Create a new string object which holds a substring of a string. |
| 213 | Handle<String> NewSubString(Handle<String> str, int begin, int end) { |
| 214 | if (begin == 0 && end == str->length()) return str; |
| 215 | return NewProperSubString(str, begin, end); |
| 216 | } |
| 217 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 218 | // Creates a new external String object. There are two String encodings |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 219 | // in the system: one-byte and two-byte. Unlike other String types, it does |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 220 | // not make sense to have a UTF-8 factory function for external strings, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 221 | // because we cannot change the underlying buffer. Note that these strings |
| 222 | // are backed by a string resource that resides outside the V8 heap. |
| 223 | MUST_USE_RESULT MaybeHandle<String> NewExternalStringFromOneByte( |
| 224 | const ExternalOneByteString::Resource* resource); |
| 225 | MUST_USE_RESULT MaybeHandle<String> NewExternalStringFromTwoByte( |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 226 | const ExternalTwoByteString::Resource* resource); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 227 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 228 | // Create a symbol. |
| 229 | Handle<Symbol> NewSymbol(); |
| 230 | Handle<Symbol> NewPrivateSymbol(); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 231 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 232 | // Create a global (but otherwise uninitialized) context. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 233 | Handle<Context> NewNativeContext(); |
| 234 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 235 | // Create a script context. |
| 236 | Handle<Context> NewScriptContext(Handle<JSFunction> function, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 237 | Handle<ScopeInfo> scope_info); |
| 238 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 239 | // Create an empty script context table. |
| 240 | Handle<ScriptContextTable> NewScriptContextTable(); |
| 241 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 242 | // Create a module context. |
| 243 | Handle<Context> NewModuleContext(Handle<ScopeInfo> scope_info); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 244 | |
| 245 | // Create a function context. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 246 | Handle<Context> NewFunctionContext(int length, Handle<JSFunction> function); |
Ben Murdoch | 3fb3ca8 | 2011-12-02 17:19:32 +0000 | [diff] [blame] | 247 | |
| 248 | // Create a catch context. |
| 249 | Handle<Context> NewCatchContext(Handle<JSFunction> function, |
| 250 | Handle<Context> previous, |
| 251 | Handle<String> name, |
| 252 | Handle<Object> thrown_object); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 253 | |
| 254 | // Create a 'with' context. |
Ben Murdoch | 3fb3ca8 | 2011-12-02 17:19:32 +0000 | [diff] [blame] | 255 | Handle<Context> NewWithContext(Handle<JSFunction> function, |
| 256 | Handle<Context> previous, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 257 | Handle<JSReceiver> extension); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 258 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 259 | // Create a block context. |
Ben Murdoch | 69a99ed | 2011-11-30 16:03:39 +0000 | [diff] [blame] | 260 | Handle<Context> NewBlockContext(Handle<JSFunction> function, |
| 261 | Handle<Context> previous, |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 262 | Handle<ScopeInfo> scope_info); |
Ben Murdoch | 69a99ed | 2011-11-30 16:03:39 +0000 | [diff] [blame] | 263 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 264 | // Allocate a new struct. The struct is pretenured (allocated directly in |
| 265 | // the old generation). |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 266 | Handle<Struct> NewStruct(InstanceType type); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 267 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 268 | Handle<CodeCache> NewCodeCache(); |
| 269 | |
| 270 | Handle<AliasedArgumentsEntry> NewAliasedArgumentsEntry( |
| 271 | int aliased_context_slot); |
| 272 | |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame^] | 273 | Handle<AccessorInfo> NewAccessorInfo(); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 274 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 275 | Handle<Script> NewScript(Handle<String> source); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 276 | |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 277 | // Foreign objects are pretenured when allocated by the bootstrapper. |
| 278 | Handle<Foreign> NewForeign(Address addr, |
| 279 | PretenureFlag pretenure = NOT_TENURED); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 280 | |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 281 | // Allocate a new foreign object. The foreign is pretenured (allocated |
| 282 | // directly in the old generation). |
| 283 | Handle<Foreign> NewForeign(const AccessorDescriptor* foreign); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 284 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 285 | Handle<ByteArray> NewByteArray(int length, |
| 286 | PretenureFlag pretenure = NOT_TENURED); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 287 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 288 | Handle<BytecodeArray> NewBytecodeArray(int length, const byte* raw_bytecodes, |
| 289 | int frame_size, int parameter_count, |
| 290 | Handle<FixedArray> constant_pool); |
| 291 | |
| 292 | Handle<FixedTypedArrayBase> NewFixedTypedArrayWithExternalPointer( |
| 293 | int length, ExternalArrayType array_type, void* external_pointer, |
Steve Block | 3ce2e20 | 2009-11-05 08:53:23 +0000 | [diff] [blame] | 294 | PretenureFlag pretenure = NOT_TENURED); |
| 295 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 296 | Handle<FixedTypedArrayBase> NewFixedTypedArray( |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 297 | int length, ExternalArrayType array_type, bool initialize, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 298 | PretenureFlag pretenure = NOT_TENURED); |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 299 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 300 | Handle<Cell> NewCell(Handle<Object> value); |
| 301 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 302 | Handle<PropertyCell> NewPropertyCell(); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 303 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 304 | Handle<WeakCell> NewWeakCell(Handle<HeapObject> value); |
| 305 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 306 | Handle<TransitionArray> NewTransitionArray(int capacity); |
| 307 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 308 | // Allocate a tenured AllocationSite. It's payload is null. |
| 309 | Handle<AllocationSite> NewAllocationSite(); |
| 310 | |
| 311 | Handle<Map> NewMap( |
| 312 | InstanceType type, |
| 313 | int instance_size, |
| 314 | ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND); |
| 315 | |
| 316 | Handle<HeapObject> NewFillerObject(int size, |
| 317 | bool double_align, |
| 318 | AllocationSpace space); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 319 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 320 | Handle<JSObject> NewFunctionPrototype(Handle<JSFunction> function); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 321 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 322 | Handle<JSObject> CopyJSObject(Handle<JSObject> object); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 323 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 324 | Handle<JSObject> CopyJSObjectWithAllocationSite(Handle<JSObject> object, |
| 325 | Handle<AllocationSite> site); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 326 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 327 | Handle<FixedArray> CopyFixedArrayWithMap(Handle<FixedArray> array, |
| 328 | Handle<Map> map); |
Steve Block | 1e0659c | 2011-05-24 12:43:12 +0100 | [diff] [blame] | 329 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 330 | Handle<FixedArray> CopyFixedArrayAndGrow( |
| 331 | Handle<FixedArray> array, int grow_by, |
| 332 | PretenureFlag pretenure = NOT_TENURED); |
| 333 | |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame^] | 334 | Handle<FixedArray> CopyFixedArrayUpTo(Handle<FixedArray> array, int new_len, |
| 335 | PretenureFlag pretenure = NOT_TENURED); |
| 336 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 337 | Handle<FixedArray> CopyFixedArray(Handle<FixedArray> array); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 338 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 339 | // This method expects a COW array in new space, and creates a copy |
| 340 | // of it in old space. |
| 341 | Handle<FixedArray> CopyAndTenureFixedCOWArray(Handle<FixedArray> array); |
| 342 | |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 343 | Handle<FixedDoubleArray> CopyFixedDoubleArray( |
| 344 | Handle<FixedDoubleArray> array); |
| 345 | |
| 346 | // Numbers (e.g. literals) are pretenured by the parser. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 347 | // The return value may be a smi or a heap number. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 348 | Handle<Object> NewNumber(double value, |
| 349 | PretenureFlag pretenure = NOT_TENURED); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 350 | |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 351 | Handle<Object> NewNumberFromInt(int32_t value, |
| 352 | PretenureFlag pretenure = NOT_TENURED); |
| 353 | Handle<Object> NewNumberFromUint(uint32_t value, |
| 354 | PretenureFlag pretenure = NOT_TENURED); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 355 | Handle<Object> NewNumberFromSize(size_t value, |
| 356 | PretenureFlag pretenure = NOT_TENURED) { |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 357 | // We can't use Smi::IsValid() here because that operates on a signed |
| 358 | // intptr_t, and casting from size_t could create a bogus sign bit. |
| 359 | if (value <= static_cast<size_t>(Smi::kMaxValue)) { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 360 | return Handle<Object>(Smi::FromIntptr(static_cast<intptr_t>(value)), |
| 361 | isolate()); |
| 362 | } |
| 363 | return NewNumber(static_cast<double>(value), pretenure); |
| 364 | } |
| 365 | Handle<HeapNumber> NewHeapNumber(double value, |
| 366 | MutableMode mode = IMMUTABLE, |
| 367 | PretenureFlag pretenure = NOT_TENURED); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 368 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 369 | #define SIMD128_NEW_DECL(TYPE, Type, type, lane_count, lane_type) \ |
| 370 | Handle<Type> New##Type(lane_type lanes[lane_count], \ |
| 371 | PretenureFlag pretenure = NOT_TENURED); |
| 372 | SIMD128_TYPES(SIMD128_NEW_DECL) |
| 373 | #undef SIMD128_NEW_DECL |
| 374 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 375 | // These objects are used by the api to create env-independent data |
| 376 | // structures in the heap. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 377 | inline Handle<JSObject> NewNeanderObject() { |
| 378 | return NewJSObjectFromMap(neander_map()); |
| 379 | } |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 380 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 381 | Handle<JSWeakMap> NewJSWeakMap(); |
| 382 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 383 | Handle<JSObject> NewArgumentsObject(Handle<JSFunction> callee, int length); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 384 | |
| 385 | // JS objects are pretenured when allocated by the bootstrapper and |
| 386 | // runtime. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 387 | Handle<JSObject> NewJSObject(Handle<JSFunction> constructor, |
| 388 | PretenureFlag pretenure = NOT_TENURED); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 389 | // JSObject that should have a memento pointing to the allocation site. |
| 390 | Handle<JSObject> NewJSObjectWithMemento(Handle<JSFunction> constructor, |
| 391 | Handle<AllocationSite> site); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 392 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 393 | // Global objects are pretenured and initialized based on a constructor. |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 394 | Handle<JSGlobalObject> NewJSGlobalObject(Handle<JSFunction> constructor); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 395 | |
| 396 | // JS objects are pretenured when allocated by the bootstrapper and |
| 397 | // runtime. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 398 | Handle<JSObject> NewJSObjectFromMap( |
| 399 | Handle<Map> map, |
| 400 | PretenureFlag pretenure = NOT_TENURED, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 401 | Handle<AllocationSite> allocation_site = Handle<AllocationSite>::null()); |
| 402 | |
| 403 | // JS modules are pretenured. |
| 404 | Handle<JSModule> NewJSModule(Handle<Context> context, |
| 405 | Handle<ScopeInfo> scope_info); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 406 | |
| 407 | // JS arrays are pretenured when allocated by the parser. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 408 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 409 | // Create a JSArray with a specified length and elements initialized |
| 410 | // according to the specified mode. |
| 411 | Handle<JSArray> NewJSArray( |
| 412 | ElementsKind elements_kind, int length, int capacity, |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 413 | Strength strength = Strength::WEAK, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 414 | ArrayStorageAllocationMode mode = DONT_INITIALIZE_ARRAY_ELEMENTS, |
| 415 | PretenureFlag pretenure = NOT_TENURED); |
| 416 | |
| 417 | Handle<JSArray> NewJSArray( |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 418 | int capacity, ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND, |
| 419 | Strength strength = Strength::WEAK, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 420 | PretenureFlag pretenure = NOT_TENURED) { |
| 421 | if (capacity != 0) { |
| 422 | elements_kind = GetHoleyElementsKind(elements_kind); |
| 423 | } |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 424 | return NewJSArray(elements_kind, 0, capacity, strength, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 425 | INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE, pretenure); |
| 426 | } |
| 427 | |
| 428 | // Create a JSArray with the given elements. |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 429 | Handle<JSArray> NewJSArrayWithElements(Handle<FixedArrayBase> elements, |
| 430 | ElementsKind elements_kind, int length, |
| 431 | Strength strength = Strength::WEAK, |
| 432 | PretenureFlag pretenure = NOT_TENURED); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 433 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 434 | Handle<JSArray> NewJSArrayWithElements( |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 435 | Handle<FixedArrayBase> elements, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 436 | ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND, |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 437 | Strength strength = Strength::WEAK, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 438 | PretenureFlag pretenure = NOT_TENURED) { |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 439 | return NewJSArrayWithElements(elements, elements_kind, elements->length(), |
| 440 | strength, pretenure); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 441 | } |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 442 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 443 | void NewJSArrayStorage( |
| 444 | Handle<JSArray> array, |
| 445 | int length, |
| 446 | int capacity, |
| 447 | ArrayStorageAllocationMode mode = DONT_INITIALIZE_ARRAY_ELEMENTS); |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 448 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 449 | Handle<JSGeneratorObject> NewJSGeneratorObject(Handle<JSFunction> function); |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 450 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 451 | Handle<JSArrayBuffer> NewJSArrayBuffer( |
| 452 | SharedFlag shared = SharedFlag::kNotShared, |
| 453 | PretenureFlag pretenure = NOT_TENURED); |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 454 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 455 | Handle<JSTypedArray> NewJSTypedArray(ExternalArrayType type, |
| 456 | PretenureFlag pretenure = NOT_TENURED); |
| 457 | |
| 458 | Handle<JSTypedArray> NewJSTypedArray(ElementsKind elements_kind, |
| 459 | PretenureFlag pretenure = NOT_TENURED); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 460 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 461 | // Creates a new JSTypedArray with the specified buffer. |
| 462 | Handle<JSTypedArray> NewJSTypedArray(ExternalArrayType type, |
| 463 | Handle<JSArrayBuffer> buffer, |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 464 | size_t byte_offset, size_t length, |
| 465 | PretenureFlag pretenure = NOT_TENURED); |
| 466 | |
| 467 | // Creates a new on-heap JSTypedArray. |
| 468 | Handle<JSTypedArray> NewJSTypedArray(ElementsKind elements_kind, |
| 469 | size_t number_of_elements, |
| 470 | PretenureFlag pretenure = NOT_TENURED); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 471 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 472 | Handle<JSDataView> NewJSDataView(); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 473 | Handle<JSDataView> NewJSDataView(Handle<JSArrayBuffer> buffer, |
| 474 | size_t byte_offset, size_t byte_length); |
| 475 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 476 | Handle<JSMap> NewJSMap(); |
| 477 | Handle<JSSet> NewJSSet(); |
| 478 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 479 | // TODO(aandrey): Maybe these should take table, index and kind arguments. |
| 480 | Handle<JSMapIterator> NewJSMapIterator(); |
| 481 | Handle<JSSetIterator> NewJSSetIterator(); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 482 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 483 | // Allocates a bound function. |
| 484 | MaybeHandle<JSBoundFunction> NewJSBoundFunction( |
| 485 | Handle<JSReceiver> target_function, Handle<Object> bound_this, |
| 486 | Vector<Handle<Object>> bound_args); |
| 487 | |
| 488 | // Allocates a Harmony proxy. |
| 489 | Handle<JSProxy> NewJSProxy(Handle<JSReceiver> target, |
| 490 | Handle<JSReceiver> handler); |
Ben Murdoch | 3fb3ca8 | 2011-12-02 17:19:32 +0000 | [diff] [blame] | 491 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 492 | // Reinitialize an JSGlobalProxy based on a constructor. The object |
| 493 | // must have the same size as objects allocated using the |
| 494 | // constructor. The object is reinitialized and behaves as an |
| 495 | // object that has been freshly allocated using the constructor. |
| 496 | void ReinitializeJSGlobalProxy(Handle<JSGlobalProxy> global, |
| 497 | Handle<JSFunction> constructor); |
| 498 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 499 | Handle<JSGlobalProxy> NewUninitializedJSGlobalProxy(); |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 500 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 501 | Handle<JSFunction> NewFunction(Handle<String> name, Handle<Code> code, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 502 | Handle<Object> prototype, |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 503 | bool read_only_prototype = false, |
| 504 | bool is_strict = false); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 505 | Handle<JSFunction> NewFunction(Handle<String> name); |
| 506 | Handle<JSFunction> NewFunctionWithoutPrototype(Handle<String> name, |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 507 | Handle<Code> code, |
| 508 | bool is_strict = false); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 509 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 510 | Handle<JSFunction> NewFunctionFromSharedFunctionInfo( |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 511 | Handle<Map> initial_map, Handle<SharedFunctionInfo> function_info, |
| 512 | Handle<Context> context, PretenureFlag pretenure = TENURED); |
| 513 | |
| 514 | Handle<JSFunction> NewFunctionFromSharedFunctionInfo( |
| 515 | Handle<SharedFunctionInfo> function_info, Handle<Context> context, |
Leon Clarke | e46be81 | 2010-01-19 14:06:41 +0000 | [diff] [blame] | 516 | PretenureFlag pretenure = TENURED); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 517 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 518 | Handle<JSFunction> NewFunction(Handle<String> name, Handle<Code> code, |
| 519 | Handle<Object> prototype, InstanceType type, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 520 | int instance_size, |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 521 | bool read_only_prototype = false, |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 522 | bool install_constructor = false, |
| 523 | bool is_strict = false); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 524 | Handle<JSFunction> NewFunction(Handle<String> name, |
| 525 | Handle<Code> code, |
| 526 | InstanceType type, |
| 527 | int instance_size); |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 528 | Handle<JSFunction> NewFunction(Handle<Map> map, Handle<String> name, |
| 529 | MaybeHandle<Code> maybe_code); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 530 | |
| 531 | // Create a serialized scope info. |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 532 | Handle<ScopeInfo> NewScopeInfo(int length); |
Ben Murdoch | 69a99ed | 2011-11-30 16:03:39 +0000 | [diff] [blame] | 533 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 534 | // Create an External object for V8's external API. |
| 535 | Handle<JSObject> NewExternal(void* value); |
| 536 | |
| 537 | // The reference to the Code object is stored in self_reference. |
| 538 | // This allows generated code to reference its own Code object |
| 539 | // by containing this handle. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 540 | Handle<Code> NewCode(const CodeDesc& desc, |
| 541 | Code::Flags flags, |
| 542 | Handle<Object> self_reference, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 543 | bool immovable = false, |
| 544 | bool crankshafted = false, |
| 545 | int prologue_offset = Code::kPrologueOffsetNotSet, |
| 546 | bool is_debug = false); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 547 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 548 | Handle<Code> CopyCode(Handle<Code> code); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 549 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 550 | Handle<Code> CopyCode(Handle<Code> code, Vector<byte> reloc_info); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 551 | |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame^] | 552 | Handle<BytecodeArray> CopyBytecodeArray(Handle<BytecodeArray>); |
| 553 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 554 | // Interface for creating error objects. |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 555 | Handle<Object> NewError(Handle<JSFunction> constructor, |
| 556 | Handle<String> message); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 557 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 558 | Handle<Object> NewInvalidStringLengthError() { |
| 559 | return NewRangeError(MessageTemplate::kInvalidStringLength); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 560 | } |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 561 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 562 | Handle<Object> NewError(Handle<JSFunction> constructor, |
| 563 | MessageTemplate::Template template_index, |
| 564 | Handle<Object> arg0 = Handle<Object>(), |
| 565 | Handle<Object> arg1 = Handle<Object>(), |
| 566 | Handle<Object> arg2 = Handle<Object>()); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 567 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 568 | #define DECLARE_ERROR(NAME) \ |
| 569 | Handle<Object> New##NAME(MessageTemplate::Template template_index, \ |
| 570 | Handle<Object> arg0 = Handle<Object>(), \ |
| 571 | Handle<Object> arg1 = Handle<Object>(), \ |
| 572 | Handle<Object> arg2 = Handle<Object>()); |
| 573 | DECLARE_ERROR(Error) |
| 574 | DECLARE_ERROR(EvalError) |
| 575 | DECLARE_ERROR(RangeError) |
| 576 | DECLARE_ERROR(ReferenceError) |
| 577 | DECLARE_ERROR(SyntaxError) |
| 578 | DECLARE_ERROR(TypeError) |
| 579 | #undef DEFINE_ERROR |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 580 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 581 | Handle<String> NumberToString(Handle<Object> number, |
| 582 | bool check_number_string_cache = true); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 583 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 584 | Handle<String> Uint32ToString(uint32_t value) { |
| 585 | return NumberToString(NewNumberFromUint(value)); |
| 586 | } |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 587 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 588 | Handle<JSFunction> InstallMembers(Handle<JSFunction> function); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 589 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 590 | #define ROOT_ACCESSOR(type, name, camel_name) \ |
| 591 | inline Handle<type> name() { \ |
| 592 | return Handle<type>(bit_cast<type**>( \ |
| 593 | &isolate()->heap()->roots_[Heap::k##camel_name##RootIndex])); \ |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 594 | } |
| 595 | ROOT_LIST(ROOT_ACCESSOR) |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 596 | #undef ROOT_ACCESSOR |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 597 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 598 | #define STRUCT_MAP_ACCESSOR(NAME, Name, name) \ |
| 599 | inline Handle<Map> name##_map() { \ |
| 600 | return Handle<Map>(bit_cast<Map**>( \ |
| 601 | &isolate()->heap()->roots_[Heap::k##Name##MapRootIndex])); \ |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 602 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 603 | STRUCT_LIST(STRUCT_MAP_ACCESSOR) |
| 604 | #undef STRUCT_MAP_ACCESSOR |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 605 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 606 | #define STRING_ACCESSOR(name, str) \ |
| 607 | inline Handle<String> name() { \ |
| 608 | return Handle<String>(bit_cast<String**>( \ |
| 609 | &isolate()->heap()->roots_[Heap::k##name##RootIndex])); \ |
| 610 | } |
| 611 | INTERNALIZED_STRING_LIST(STRING_ACCESSOR) |
| 612 | #undef STRING_ACCESSOR |
| 613 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 614 | #define SYMBOL_ACCESSOR(name) \ |
| 615 | inline Handle<Symbol> name() { \ |
| 616 | return Handle<Symbol>(bit_cast<Symbol**>( \ |
| 617 | &isolate()->heap()->roots_[Heap::k##name##RootIndex])); \ |
| 618 | } |
| 619 | PRIVATE_SYMBOL_LIST(SYMBOL_ACCESSOR) |
| 620 | #undef SYMBOL_ACCESSOR |
| 621 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 622 | #define SYMBOL_ACCESSOR(name, description) \ |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 623 | inline Handle<Symbol> name() { \ |
| 624 | return Handle<Symbol>(bit_cast<Symbol**>( \ |
| 625 | &isolate()->heap()->roots_[Heap::k##name##RootIndex])); \ |
| 626 | } |
| 627 | PUBLIC_SYMBOL_LIST(SYMBOL_ACCESSOR) |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 628 | WELL_KNOWN_SYMBOL_LIST(SYMBOL_ACCESSOR) |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 629 | #undef SYMBOL_ACCESSOR |
| 630 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 631 | // Allocates a new SharedFunctionInfo object. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 632 | Handle<SharedFunctionInfo> NewSharedFunctionInfo( |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 633 | Handle<String> name, int number_of_literals, FunctionKind kind, |
| 634 | Handle<Code> code, Handle<ScopeInfo> scope_info, |
| 635 | Handle<TypeFeedbackVector> feedback_vector); |
| 636 | Handle<SharedFunctionInfo> NewSharedFunctionInfo(Handle<String> name, |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 637 | MaybeHandle<Code> code, |
| 638 | bool is_constructor); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 639 | |
| 640 | // Allocates a new JSMessageObject object. |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 641 | Handle<JSMessageObject> NewJSMessageObject(MessageTemplate::Template message, |
| 642 | Handle<Object> argument, |
| 643 | int start_position, |
| 644 | int end_position, |
| 645 | Handle<Object> script, |
| 646 | Handle<Object> stack_frames); |
Steve Block | 1e0659c | 2011-05-24 12:43:12 +0100 | [diff] [blame] | 647 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 648 | Handle<DebugInfo> NewDebugInfo(Handle<SharedFunctionInfo> shared); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 649 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 650 | // Return a map for given number of properties using the map cache in the |
| 651 | // native context. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 652 | Handle<Map> ObjectLiteralMapFromCache(Handle<Context> context, |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 653 | int number_of_properties, |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 654 | bool is_strong, |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 655 | bool* is_result_from_cache); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 656 | |
| 657 | // Creates a new FixedArray that holds the data associated with the |
| 658 | // atom regexp and stores it in the regexp. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 659 | void SetRegExpAtomData(Handle<JSRegExp> regexp, |
| 660 | JSRegExp::Type type, |
| 661 | Handle<String> source, |
| 662 | JSRegExp::Flags flags, |
| 663 | Handle<Object> match_pattern); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 664 | |
| 665 | // Creates a new FixedArray that holds the data associated with the |
| 666 | // irregexp regexp and stores it in the regexp. |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 667 | void SetRegExpIrregexpData(Handle<JSRegExp> regexp, |
| 668 | JSRegExp::Type type, |
| 669 | Handle<String> source, |
| 670 | JSRegExp::Flags flags, |
| 671 | int capture_count); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 672 | |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 673 | // Returns the value for a known global constant (a property of the global |
| 674 | // object which is neither configurable nor writable) like 'undefined'. |
| 675 | // Returns a null handle when the given name is unknown. |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 676 | Handle<Object> GlobalConstantFor(Handle<Name> name); |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 677 | |
| 678 | // Converts the given boolean condition to JavaScript boolean value. |
| 679 | Handle<Object> ToBoolean(bool value); |
| 680 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 681 | private: |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 682 | Isolate* isolate() { return reinterpret_cast<Isolate*>(this); } |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 683 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 684 | // Creates a heap object based on the map. The fields of the heap object are |
| 685 | // not initialized by New<>() functions. It's the responsibility of the caller |
| 686 | // to do that. |
| 687 | template<typename T> |
| 688 | Handle<T> New(Handle<Map> map, AllocationSpace space); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 689 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 690 | template<typename T> |
| 691 | Handle<T> New(Handle<Map> map, |
| 692 | AllocationSpace space, |
| 693 | Handle<AllocationSite> allocation_site); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 694 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 695 | // Creates a code object that is not yet fully initialized yet. |
| 696 | inline Handle<Code> NewCodeRaw(int object_size, bool immovable); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 697 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 698 | // Attempt to find the number in a small cache. If we finds it, return |
| 699 | // the string representation of the number. Otherwise return undefined. |
| 700 | Handle<Object> GetNumberStringCache(Handle<Object> number); |
| 701 | |
| 702 | // Update the cache with a new number-string pair. |
| 703 | void SetNumberStringCache(Handle<Object> number, Handle<String> string); |
| 704 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 705 | // Creates a function initialized with a shared part. |
| 706 | Handle<JSFunction> NewFunction(Handle<Map> map, |
| 707 | Handle<SharedFunctionInfo> info, |
| 708 | Handle<Context> context, |
| 709 | PretenureFlag pretenure = TENURED); |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame^] | 710 | |
| 711 | // Create a JSArray with no elements and no length. |
| 712 | Handle<JSArray> NewJSArray(ElementsKind elements_kind, |
| 713 | Strength strength = Strength::WEAK, |
| 714 | PretenureFlag pretenure = NOT_TENURED); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 715 | }; |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 716 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 717 | } // namespace internal |
| 718 | } // namespace v8 |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 719 | |
| 720 | #endif // V8_FACTORY_H_ |