factory.h revision 44f0eee88ff00398ff7f715fab053374d808c90d 
1// Copyright 2010 the V8 project authors. All rights reserved.
2// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6//     * Redistributions of source code must retain the above copyright
7//       notice, this list of conditions and the following disclaimer.
8//     * Redistributions in binary form must reproduce the above
9//       copyright notice, this list of conditions and the following
10//       disclaimer in the documentation and/or other materials provided
11//       with the distribution.
12//     * Neither the name of Google Inc. nor the names of its
13//       contributors may be used to endorse or promote products derived
14//       from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28#ifndef V8_FACTORY_H_
29#define V8_FACTORY_H_
30
31#include "globals.h"
32#include "handles.h"
33#include "heap.h"
34
35namespace v8 {
36namespace internal {
37
38// Interface for handle based allocation.
39
40class Factory {
41 public:
42  // Allocate a new fixed array with undefined entries.
43  Handle<FixedArray> NewFixedArray(
44      int size,
45      PretenureFlag pretenure = NOT_TENURED);
46
47  // Allocate a new fixed array with non-existing entries (the hole).
48  Handle<FixedArray> NewFixedArrayWithHoles(
49      int size,
50      PretenureFlag pretenure = NOT_TENURED);
51
52  Handle<NumberDictionary> NewNumberDictionary(int at_least_space_for);
53
54  Handle<StringDictionary> NewStringDictionary(int at_least_space_for);
55
56  Handle<DescriptorArray> NewDescriptorArray(int number_of_descriptors);
57  Handle<DeoptimizationInputData> NewDeoptimizationInputData(
58      int deopt_entry_count,
59      PretenureFlag pretenure);
60  Handle<DeoptimizationOutputData> NewDeoptimizationOutputData(
61      int deopt_entry_count,
62      PretenureFlag pretenure);
63
64  Handle<String> LookupSymbol(Vector<const char> str);
65  Handle<String> LookupAsciiSymbol(Vector<const char> str);
66  Handle<String> LookupTwoByteSymbol(Vector<const uc16> str);
67  Handle<String> LookupAsciiSymbol(const char* str) {
68    return LookupSymbol(CStrVector(str));
69  }
70
71
72  // String creation functions.  Most of the string creation functions take
73  // a Heap::PretenureFlag argument to optionally request that they be
74  // allocated in the old generation.  The pretenure flag defaults to
75  // DONT_TENURE.
76  //
77  // Creates a new String object.  There are two String encodings: ASCII and
78  // two byte.  One should choose between the three string factory functions
79  // based on the encoding of the string buffer that the string is
80  // initialized from.
81  //   - ...FromAscii initializes the string from a buffer that is ASCII
82  //     encoded (it does not check that the buffer is ASCII encoded) and
83  //     the result will be ASCII encoded.
84  //   - ...FromUtf8 initializes the string from a buffer that is UTF-8
85  //     encoded.  If the characters are all single-byte characters, the
86  //     result will be ASCII encoded, otherwise it will converted to two
87  //     byte.
88  //   - ...FromTwoByte initializes the string from a buffer that is two
89  //     byte encoded.  If the characters are all single-byte characters,
90  //     the result will be converted to ASCII, otherwise it will be left as
91  //     two byte.
92  //
93  // ASCII strings are pretenured when used as keys in the SourceCodeCache.
94  Handle<String> NewStringFromAscii(
95      Vector<const char> str,
96      PretenureFlag pretenure = NOT_TENURED);
97
98  // UTF8 strings are pretenured when used for regexp literal patterns and
99  // flags in the parser.
100  Handle<String> NewStringFromUtf8(
101      Vector<const char> str,
102      PretenureFlag pretenure = NOT_TENURED);
103
104  Handle<String> NewStringFromTwoByte(
105      Vector<const uc16> str,
106      PretenureFlag pretenure = NOT_TENURED);
107
108  // Allocates and partially initializes an ASCII or TwoByte String. The
109  // characters of the string are uninitialized. Currently used in regexp code
110  // only, where they are pretenured.
111  Handle<String> NewRawAsciiString(
112      int length,
113      PretenureFlag pretenure = NOT_TENURED);
114  Handle<String> NewRawTwoByteString(
115      int length,
116      PretenureFlag pretenure = NOT_TENURED);
117
118  // Create a new cons string object which consists of a pair of strings.
119  Handle<String> NewConsString(Handle<String> first,
120                               Handle<String> second);
121
122  // Create a new string object which holds a substring of a string.
123  Handle<String> NewSubString(Handle<String> str,
124                              int begin,
125                              int end);
126
127  // Creates a new external String object.  There are two String encodings
128  // in the system: ASCII and two byte.  Unlike other String types, it does
129  // not make sense to have a UTF-8 factory function for external strings,
130  // because we cannot change the underlying buffer.
131  Handle<String> NewExternalStringFromAscii(
132      ExternalAsciiString::Resource* resource);
133  Handle<String> NewExternalStringFromTwoByte(
134      ExternalTwoByteString::Resource* resource);
135
136  // Create a global (but otherwise uninitialized) context.
137  Handle<Context> NewGlobalContext();
138
139  // Create a function context.
140  Handle<Context> NewFunctionContext(int length,
141                                     Handle<JSFunction> closure);
142
143  // Create a 'with' context.
144  Handle<Context> NewWithContext(Handle<Context> previous,
145                                 Handle<JSObject> extension,
146                                 bool is_catch_context);
147
148  // Return the Symbol matching the passed in string.
149  Handle<String> SymbolFromString(Handle<String> value);
150
151  // Allocate a new struct.  The struct is pretenured (allocated directly in
152  // the old generation).
153  Handle<Struct> NewStruct(InstanceType type);
154
155  Handle<AccessorInfo> NewAccessorInfo();
156
157  Handle<Script> NewScript(Handle<String> source);
158
159  // Proxies are pretenured when allocated by the bootstrapper.
160  Handle<Proxy> NewProxy(Address addr,
161                         PretenureFlag pretenure = NOT_TENURED);
162
163  // Allocate a new proxy.  The proxy is pretenured (allocated directly in
164  // the old generation).
165  Handle<Proxy> NewProxy(const AccessorDescriptor* proxy);
166
167  Handle<ByteArray> NewByteArray(int length,
168                                 PretenureFlag pretenure = NOT_TENURED);
169
170  Handle<ExternalArray> NewExternalArray(
171      int length,
172      ExternalArrayType array_type,
173      void* external_pointer,
174      PretenureFlag pretenure = NOT_TENURED);
175
176  Handle<JSGlobalPropertyCell> NewJSGlobalPropertyCell(
177      Handle<Object> value);
178
179  Handle<Map> NewMap(InstanceType type, int instance_size);
180
181  Handle<JSObject> NewFunctionPrototype(Handle<JSFunction> function);
182
183  Handle<Map> CopyMapDropDescriptors(Handle<Map> map);
184
185  // Copy the map adding more inobject properties if possible without
186  // overflowing the instance size.
187  Handle<Map> CopyMap(Handle<Map> map, int extra_inobject_props);
188
189  Handle<Map> CopyMapDropTransitions(Handle<Map> map);
190
191  Handle<Map> GetFastElementsMap(Handle<Map> map);
192
193  Handle<Map> GetSlowElementsMap(Handle<Map> map);
194
195  Handle<Map> GetExternalArrayElementsMap(Handle<Map> map,
196                                          ExternalArrayType array_type,
197                                          bool safe_to_add_transition);
198
199  Handle<FixedArray> CopyFixedArray(Handle<FixedArray> array);
200
201  // Numbers (eg, literals) are pretenured by the parser.
202  Handle<Object> NewNumber(double value,
203                           PretenureFlag pretenure = NOT_TENURED);
204
205  Handle<Object> NewNumberFromInt(int value);
206  Handle<Object> NewNumberFromUint(uint32_t value);
207
208  // These objects are used by the api to create env-independent data
209  // structures in the heap.
210  Handle<JSObject> NewNeanderObject();
211
212  Handle<JSObject> NewArgumentsObject(Handle<Object> callee, int length);
213
214  // JS objects are pretenured when allocated by the bootstrapper and
215  // runtime.
216  Handle<JSObject> NewJSObject(Handle<JSFunction> constructor,
217                               PretenureFlag pretenure = NOT_TENURED);
218
219  // Global objects are pretenured.
220  Handle<GlobalObject> NewGlobalObject(Handle<JSFunction> constructor);
221
222  // JS objects are pretenured when allocated by the bootstrapper and
223  // runtime.
224  Handle<JSObject> NewJSObjectFromMap(Handle<Map> map);
225
226  // JS arrays are pretenured when allocated by the parser.
227  Handle<JSArray> NewJSArray(int capacity,
228                             PretenureFlag pretenure = NOT_TENURED);
229
230  Handle<JSArray> NewJSArrayWithElements(
231      Handle<FixedArray> elements,
232      PretenureFlag pretenure = NOT_TENURED);
233
234  Handle<JSFunction> NewFunction(Handle<String> name,
235                                 Handle<Object> prototype);
236
237  Handle<JSFunction> NewFunctionWithoutPrototype(
238      Handle<String> name,
239      StrictModeFlag strict_mode);
240
241  Handle<JSFunction> NewFunction(Handle<Object> super, bool is_global);
242
243  Handle<JSFunction> BaseNewFunctionFromSharedFunctionInfo(
244      Handle<SharedFunctionInfo> function_info,
245      Handle<Map> function_map,
246      PretenureFlag pretenure);
247
248  Handle<JSFunction> NewFunctionFromSharedFunctionInfo(
249      Handle<SharedFunctionInfo> function_info,
250      Handle<Context> context,
251      PretenureFlag pretenure = TENURED);
252
253  Handle<Code> NewCode(const CodeDesc& desc,
254                       Code::Flags flags,
255                       Handle<Object> self_reference,
256                       bool immovable = false);
257
258  Handle<Code> CopyCode(Handle<Code> code);
259
260  Handle<Code> CopyCode(Handle<Code> code, Vector<byte> reloc_info);
261
262  Handle<Object> ToObject(Handle<Object> object);
263  Handle<Object> ToObject(Handle<Object> object,
264                          Handle<Context> global_context);
265
266  // Interface for creating error objects.
267
268  Handle<Object> NewError(const char* maker, const char* type,
269                          Handle<JSArray> args);
270  Handle<Object> NewError(const char* maker, const char* type,
271                          Vector< Handle<Object> > args);
272  Handle<Object> NewError(const char* type,
273                          Vector< Handle<Object> > args);
274  Handle<Object> NewError(Handle<String> message);
275  Handle<Object> NewError(const char* constructor,
276                          Handle<String> message);
277
278  Handle<Object> NewTypeError(const char* type,
279                              Vector< Handle<Object> > args);
280  Handle<Object> NewTypeError(Handle<String> message);
281
282  Handle<Object> NewRangeError(const char* type,
283                               Vector< Handle<Object> > args);
284  Handle<Object> NewRangeError(Handle<String> message);
285
286  Handle<Object> NewSyntaxError(const char* type, Handle<JSArray> args);
287  Handle<Object> NewSyntaxError(Handle<String> message);
288
289  Handle<Object> NewReferenceError(const char* type,
290                                   Vector< Handle<Object> > args);
291  Handle<Object> NewReferenceError(Handle<String> message);
292
293  Handle<Object> NewEvalError(const char* type,
294                              Vector< Handle<Object> > args);
295
296
297  Handle<JSFunction> NewFunction(Handle<String> name,
298                                 InstanceType type,
299                                 int instance_size,
300                                 Handle<Code> code,
301                                 bool force_initial_map);
302
303  Handle<JSFunction> NewFunction(Handle<Map> function_map,
304      Handle<SharedFunctionInfo> shared, Handle<Object> prototype);
305
306
307  Handle<JSFunction> NewFunctionWithPrototype(Handle<String> name,
308                                              InstanceType type,
309                                              int instance_size,
310                                              Handle<JSObject> prototype,
311                                              Handle<Code> code,
312                                              bool force_initial_map);
313
314  Handle<JSFunction> NewFunctionWithoutPrototype(Handle<String> name,
315                                                 Handle<Code> code);
316
317  Handle<DescriptorArray> CopyAppendProxyDescriptor(
318      Handle<DescriptorArray> array,
319      Handle<String> key,
320      Handle<Object> value,
321      PropertyAttributes attributes);
322
323  Handle<String> NumberToString(Handle<Object> number);
324
325  enum ApiInstanceType {
326    JavaScriptObject,
327    InnerGlobalObject,
328    OuterGlobalObject
329  };
330
331  Handle<JSFunction> CreateApiFunction(
332      Handle<FunctionTemplateInfo> data,
333      ApiInstanceType type = JavaScriptObject);
334
335  Handle<JSFunction> InstallMembers(Handle<JSFunction> function);
336
337  // Installs interceptors on the instance.  'desc' is a function template,
338  // and instance is an object instance created by the function of this
339  // function template.
340  void ConfigureInstance(Handle<FunctionTemplateInfo> desc,
341                         Handle<JSObject> instance,
342                         bool* pending_exception);
343
344#define ROOT_ACCESSOR(type, name, camel_name)                                  \
345  inline Handle<type> name() {                                                 \
346    return Handle<type>(BitCast<type**>(                                       \
347        &isolate()->heap()->roots_[Heap::k##camel_name##RootIndex]));          \
348  }
349  ROOT_LIST(ROOT_ACCESSOR)
350#undef ROOT_ACCESSOR_ACCESSOR
351
352#define SYMBOL_ACCESSOR(name, str)                                             \
353  inline Handle<String> name() {                                               \
354    return Handle<String>(BitCast<String**>(                                   \
355        &isolate()->heap()->roots_[Heap::k##name##RootIndex]));                \
356  }
357  SYMBOL_LIST(SYMBOL_ACCESSOR)
358#undef SYMBOL_ACCESSOR
359
360  Handle<String> hidden_symbol() {
361    return Handle<String>(&isolate()->heap()->hidden_symbol_);
362  }
363
364  Handle<SharedFunctionInfo> NewSharedFunctionInfo(
365      Handle<String> name,
366      int number_of_literals,
367      Handle<Code> code,
368      Handle<SerializedScopeInfo> scope_info);
369  Handle<SharedFunctionInfo> NewSharedFunctionInfo(Handle<String> name);
370
371  Handle<JSMessageObject> NewJSMessageObject(
372      Handle<String> type,
373      Handle<JSArray> arguments,
374      int start_position,
375      int end_position,
376      Handle<Object> script,
377      Handle<Object> stack_trace,
378      Handle<Object> stack_frames);
379
380  Handle<NumberDictionary> DictionaryAtNumberPut(
381      Handle<NumberDictionary>,
382      uint32_t key,
383      Handle<Object> value);
384
385#ifdef ENABLE_DEBUGGER_SUPPORT
386  Handle<DebugInfo> NewDebugInfo(Handle<SharedFunctionInfo> shared);
387#endif
388
389  // Return a map using the map cache in the global context.
390  // The key the an ordered set of property names.
391  Handle<Map> ObjectLiteralMapFromCache(Handle<Context> context,
392                                        Handle<FixedArray> keys);
393
394  // Creates a new FixedArray that holds the data associated with the
395  // atom regexp and stores it in the regexp.
396  void SetRegExpAtomData(Handle<JSRegExp> regexp,
397                         JSRegExp::Type type,
398                         Handle<String> source,
399                         JSRegExp::Flags flags,
400                         Handle<Object> match_pattern);
401
402  // Creates a new FixedArray that holds the data associated with the
403  // irregexp regexp and stores it in the regexp.
404  void SetRegExpIrregexpData(Handle<JSRegExp> regexp,
405                             JSRegExp::Type type,
406                             Handle<String> source,
407                             JSRegExp::Flags flags,
408                             int capture_count);
409
410 private:
411  Isolate* isolate() { return reinterpret_cast<Isolate*>(this); }
412
413  Handle<JSFunction> NewFunctionHelper(Handle<String> name,
414                                       Handle<Object> prototype);
415
416  Handle<JSFunction> NewFunctionWithoutPrototypeHelper(
417      Handle<String> name,
418      StrictModeFlag strict_mode);
419
420  Handle<DescriptorArray> CopyAppendCallbackDescriptors(
421      Handle<DescriptorArray> array,
422      Handle<Object> descriptors);
423
424  // Create a new map cache.
425  Handle<MapCache> NewMapCache(int at_least_space_for);
426
427  // Update the map cache in the global context with (keys, map)
428  Handle<MapCache> AddToMapCache(Handle<Context> context,
429                                 Handle<FixedArray> keys,
430                                 Handle<Map> map);
431};
432
433
434} }  // namespace v8::internal
435
436#endif  // V8_FACTORY_H_
437