blob: 8d207496418e99b12f0537d9ffc0ec66a77e6205 [file] [log] [blame]
ager@chromium.org9258b6b2008-09-11 09:11:10 +00001// Copyright 2006-2008 the V8 project authors. All rights reserved.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002// 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#include "v8.h"
29
30#include "api.h"
v8.team.kasperl727e9952008-09-02 14:56:44 +000031#include "debug.h"
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000032#include "execution.h"
33#include "factory.h"
34#include "macro-assembler.h"
35
kasperl@chromium.org71affb52009-05-26 05:44:31 +000036namespace v8 {
37namespace internal {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000038
39
40Handle<FixedArray> Factory::NewFixedArray(int size, PretenureFlag pretenure) {
41 ASSERT(0 <= size);
42 CALL_HEAP_FUNCTION(Heap::AllocateFixedArray(size, pretenure), FixedArray);
43}
44
45
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +000046Handle<FixedArray> Factory::NewFixedArrayWithHoles(int size) {
47 ASSERT(0 <= size);
48 CALL_HEAP_FUNCTION(Heap::AllocateFixedArrayWithHoles(size), FixedArray);
49}
50
51
kasperl@chromium.org86f77b72009-07-06 08:21:57 +000052Handle<StringDictionary> Factory::NewStringDictionary(int at_least_space_for) {
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +000053 ASSERT(0 <= at_least_space_for);
kasperl@chromium.org86f77b72009-07-06 08:21:57 +000054 CALL_HEAP_FUNCTION(StringDictionary::Allocate(at_least_space_for),
55 StringDictionary);
56}
57
58
59Handle<NumberDictionary> Factory::NewNumberDictionary(int at_least_space_for) {
60 ASSERT(0 <= at_least_space_for);
61 CALL_HEAP_FUNCTION(NumberDictionary::Allocate(at_least_space_for),
62 NumberDictionary);
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +000063}
64
65
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000066Handle<DescriptorArray> Factory::NewDescriptorArray(int number_of_descriptors) {
67 ASSERT(0 <= number_of_descriptors);
68 CALL_HEAP_FUNCTION(DescriptorArray::Allocate(number_of_descriptors),
69 DescriptorArray);
70}
71
72
ager@chromium.org9258b6b2008-09-11 09:11:10 +000073// Symbols are created in the old generation (data space).
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000074Handle<String> Factory::LookupSymbol(Vector<const char> string) {
75 CALL_HEAP_FUNCTION(Heap::LookupSymbol(string), String);
76}
77
78
79Handle<String> Factory::NewStringFromAscii(Vector<const char> string,
80 PretenureFlag pretenure) {
81 CALL_HEAP_FUNCTION(Heap::AllocateStringFromAscii(string, pretenure), String);
82}
83
84Handle<String> Factory::NewStringFromUtf8(Vector<const char> string,
85 PretenureFlag pretenure) {
86 CALL_HEAP_FUNCTION(Heap::AllocateStringFromUtf8(string, pretenure), String);
87}
88
89
sgjesse@chromium.org911335c2009-08-19 12:59:44 +000090Handle<String> Factory::NewStringFromTwoByte(Vector<const uc16> string,
91 PretenureFlag pretenure) {
92 CALL_HEAP_FUNCTION(Heap::AllocateStringFromTwoByte(string, pretenure),
93 String);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000094}
95
96
97Handle<String> Factory::NewRawTwoByteString(int length,
98 PretenureFlag pretenure) {
99 CALL_HEAP_FUNCTION(Heap::AllocateRawTwoByteString(length, pretenure), String);
100}
101
102
103Handle<String> Factory::NewConsString(Handle<String> first,
ager@chromium.orgbb29dc92009-03-24 13:25:23 +0000104 Handle<String> second) {
ager@chromium.orgc3e50d82008-11-05 11:53:10 +0000105 CALL_HEAP_FUNCTION(Heap::AllocateConsString(*first, *second), String);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000106}
107
108
ager@chromium.orgc4c92722009-11-18 14:12:51 +0000109Handle<String> Factory::NewSubString(Handle<String> str,
110 int begin,
111 int end) {
112 CALL_HEAP_FUNCTION(str->SubString(begin, end), String);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000113}
114
115
116Handle<String> Factory::NewExternalStringFromAscii(
117 ExternalAsciiString::Resource* resource) {
118 CALL_HEAP_FUNCTION(Heap::AllocateExternalStringFromAscii(resource), String);
119}
120
121
122Handle<String> Factory::NewExternalStringFromTwoByte(
123 ExternalTwoByteString::Resource* resource) {
124 CALL_HEAP_FUNCTION(Heap::AllocateExternalStringFromTwoByte(resource), String);
125}
126
127
128Handle<Context> Factory::NewGlobalContext() {
129 CALL_HEAP_FUNCTION(Heap::AllocateGlobalContext(), Context);
130}
131
132
133Handle<Context> Factory::NewFunctionContext(int length,
134 Handle<JSFunction> closure) {
135 CALL_HEAP_FUNCTION(Heap::AllocateFunctionContext(length, *closure), Context);
136}
137
138
139Handle<Context> Factory::NewWithContext(Handle<Context> previous,
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +0000140 Handle<JSObject> extension,
141 bool is_catch_context) {
142 CALL_HEAP_FUNCTION(Heap::AllocateWithContext(*previous,
143 *extension,
144 is_catch_context),
145 Context);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000146}
147
148
149Handle<Struct> Factory::NewStruct(InstanceType type) {
150 CALL_HEAP_FUNCTION(Heap::AllocateStruct(type), Struct);
151}
152
153
154Handle<AccessorInfo> Factory::NewAccessorInfo() {
155 Handle<AccessorInfo> info =
156 Handle<AccessorInfo>::cast(NewStruct(ACCESSOR_INFO_TYPE));
157 info->set_flag(0); // Must clear the flag, it was initialized as undefined.
158 return info;
159}
160
161
162Handle<Script> Factory::NewScript(Handle<String> source) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000163 // Generate id for this script.
164 int id;
165 if (Heap::last_script_id()->IsUndefined()) {
166 // Script ids start from one.
167 id = 1;
168 } else {
169 // Increment id, wrap when positive smi is exhausted.
170 id = Smi::cast(Heap::last_script_id())->value();
171 id++;
172 if (!Smi::IsValid(id)) {
173 id = 0;
174 }
175 }
176 Heap::SetLastScriptId(Smi::FromInt(id));
177
178 // Create and initialize script object.
ager@chromium.org9085a012009-05-11 19:22:57 +0000179 Handle<Proxy> wrapper = Factory::NewProxy(0, TENURED);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000180 Handle<Script> script = Handle<Script>::cast(NewStruct(SCRIPT_TYPE));
181 script->set_source(*source);
182 script->set_name(Heap::undefined_value());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000183 script->set_id(Heap::last_script_id());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000184 script->set_line_offset(Smi::FromInt(0));
185 script->set_column_offset(Smi::FromInt(0));
ager@chromium.org65dad4b2009-04-23 08:48:43 +0000186 script->set_data(Heap::undefined_value());
ager@chromium.org9085a012009-05-11 19:22:57 +0000187 script->set_context_data(Heap::undefined_value());
ager@chromium.orge2902be2009-06-08 12:21:35 +0000188 script->set_type(Smi::FromInt(Script::TYPE_NORMAL));
189 script->set_compilation_type(Smi::FromInt(Script::COMPILATION_TYPE_HOST));
ager@chromium.org9085a012009-05-11 19:22:57 +0000190 script->set_wrapper(*wrapper);
sgjesse@chromium.org499aaa52009-11-30 08:07:20 +0000191 script->set_line_ends(Heap::undefined_value());
sgjesse@chromium.org98180592009-12-02 08:17:28 +0000192 script->set_eval_from_shared(Heap::undefined_value());
ager@chromium.orge2902be2009-06-08 12:21:35 +0000193 script->set_eval_from_instructions_offset(Smi::FromInt(0));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000194
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000195 return script;
196}
197
198
199Handle<Proxy> Factory::NewProxy(Address addr, PretenureFlag pretenure) {
200 CALL_HEAP_FUNCTION(Heap::AllocateProxy(addr, pretenure), Proxy);
201}
202
203
204Handle<Proxy> Factory::NewProxy(const AccessorDescriptor* desc) {
205 return NewProxy((Address) desc, TENURED);
206}
207
208
ager@chromium.orga74f0da2008-12-03 16:05:52 +0000209Handle<ByteArray> Factory::NewByteArray(int length, PretenureFlag pretenure) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000210 ASSERT(0 <= length);
ager@chromium.orga74f0da2008-12-03 16:05:52 +0000211 CALL_HEAP_FUNCTION(Heap::AllocateByteArray(length, pretenure), ByteArray);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000212}
213
214
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +0000215Handle<PixelArray> Factory::NewPixelArray(int length,
216 uint8_t* external_pointer,
217 PretenureFlag pretenure) {
218 ASSERT(0 <= length);
219 CALL_HEAP_FUNCTION(Heap::AllocatePixelArray(length,
220 external_pointer,
221 pretenure), PixelArray);
222}
223
224
ager@chromium.org3811b432009-10-28 14:53:37 +0000225Handle<ExternalArray> Factory::NewExternalArray(int length,
226 ExternalArrayType array_type,
227 void* external_pointer,
228 PretenureFlag pretenure) {
229 ASSERT(0 <= length);
230 CALL_HEAP_FUNCTION(Heap::AllocateExternalArray(length,
231 array_type,
232 external_pointer,
233 pretenure), ExternalArray);
234}
235
236
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000237Handle<Map> Factory::NewMap(InstanceType type, int instance_size) {
238 CALL_HEAP_FUNCTION(Heap::AllocateMap(type, instance_size), Map);
239}
240
241
242Handle<JSObject> Factory::NewFunctionPrototype(Handle<JSFunction> function) {
243 CALL_HEAP_FUNCTION(Heap::AllocateFunctionPrototype(*function), JSObject);
244}
245
246
ager@chromium.org3a37e9b2009-04-27 09:26:21 +0000247Handle<Map> Factory::CopyMapDropDescriptors(Handle<Map> src) {
248 CALL_HEAP_FUNCTION(src->CopyDropDescriptors(), Map);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000249}
250
251
ager@chromium.org32912102009-01-16 10:38:43 +0000252Handle<Map> Factory::CopyMap(Handle<Map> src,
253 int extra_inobject_properties) {
ager@chromium.org3a37e9b2009-04-27 09:26:21 +0000254 Handle<Map> copy = CopyMapDropDescriptors(src);
ager@chromium.org32912102009-01-16 10:38:43 +0000255 // Check that we do not overflow the instance size when adding the
256 // extra inobject properties.
257 int instance_size_delta = extra_inobject_properties * kPointerSize;
258 int max_instance_size_delta =
259 JSObject::kMaxInstanceSize - copy->instance_size();
260 if (instance_size_delta > max_instance_size_delta) {
261 // If the instance size overflows, we allocate as many properties
262 // as we can as inobject properties.
263 instance_size_delta = max_instance_size_delta;
264 extra_inobject_properties = max_instance_size_delta >> kPointerSizeLog2;
265 }
266 // Adjust the map with the extra inobject properties.
267 int inobject_properties =
268 copy->inobject_properties() + extra_inobject_properties;
269 copy->set_inobject_properties(inobject_properties);
270 copy->set_unused_property_fields(inobject_properties);
271 copy->set_instance_size(copy->instance_size() + instance_size_delta);
272 return copy;
273}
274
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000275Handle<Map> Factory::CopyMapDropTransitions(Handle<Map> src) {
276 CALL_HEAP_FUNCTION(src->CopyDropTransitions(), Map);
277}
278
279
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000280Handle<FixedArray> Factory::CopyFixedArray(Handle<FixedArray> array) {
281 CALL_HEAP_FUNCTION(array->Copy(), FixedArray);
282}
283
284
285Handle<JSFunction> Factory::BaseNewFunctionFromBoilerplate(
286 Handle<JSFunction> boilerplate,
sgjesse@chromium.org846fb742009-12-18 08:56:33 +0000287 Handle<Map> function_map,
288 PretenureFlag pretenure) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000289 ASSERT(boilerplate->IsBoilerplate());
290 ASSERT(!boilerplate->has_initial_map());
291 ASSERT(!boilerplate->has_prototype());
292 ASSERT(boilerplate->properties() == Heap::empty_fixed_array());
293 ASSERT(boilerplate->elements() == Heap::empty_fixed_array());
294 CALL_HEAP_FUNCTION(Heap::AllocateFunction(*function_map,
295 boilerplate->shared(),
sgjesse@chromium.org846fb742009-12-18 08:56:33 +0000296 Heap::the_hole_value(),
297 pretenure),
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000298 JSFunction);
299}
300
301
302Handle<JSFunction> Factory::NewFunctionFromBoilerplate(
303 Handle<JSFunction> boilerplate,
sgjesse@chromium.org846fb742009-12-18 08:56:33 +0000304 Handle<Context> context,
305 PretenureFlag pretenure) {
306 Handle<JSFunction> result = BaseNewFunctionFromBoilerplate(
307 boilerplate, Top::function_map(), pretenure);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000308 result->set_context(*context);
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000309 int number_of_literals = boilerplate->NumberOfLiterals();
310 Handle<FixedArray> literals =
sgjesse@chromium.org846fb742009-12-18 08:56:33 +0000311 Factory::NewFixedArray(number_of_literals, pretenure);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000312 if (number_of_literals > 0) {
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000313 // Store the object, regexp and array functions in the literals
314 // array prefix. These functions will be used when creating
315 // object, regexp and array literals in this function.
ager@chromium.org236ad962008-09-25 09:45:57 +0000316 literals->set(JSFunction::kLiteralGlobalContextIndex,
317 context->global_context());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000318 }
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000319 result->set_literals(*literals);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000320 ASSERT(!result->IsBoilerplate());
321 return result;
322}
323
324
325Handle<Object> Factory::NewNumber(double value,
326 PretenureFlag pretenure) {
327 CALL_HEAP_FUNCTION(Heap::NumberFromDouble(value, pretenure), Object);
328}
329
330
331Handle<Object> Factory::NewNumberFromInt(int value) {
332 CALL_HEAP_FUNCTION(Heap::NumberFromInt32(value), Object);
333}
334
335
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000336Handle<Object> Factory::NewNumberFromUint(uint32_t value) {
337 CALL_HEAP_FUNCTION(Heap::NumberFromUint32(value), Object);
338}
339
340
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000341Handle<JSObject> Factory::NewNeanderObject() {
342 CALL_HEAP_FUNCTION(Heap::AllocateJSObjectFromMap(Heap::neander_map()),
343 JSObject);
344}
345
346
347Handle<Object> Factory::NewTypeError(const char* type,
348 Vector< Handle<Object> > args) {
349 return NewError("MakeTypeError", type, args);
350}
351
352
353Handle<Object> Factory::NewTypeError(Handle<String> message) {
354 return NewError("$TypeError", message);
355}
356
357
358Handle<Object> Factory::NewRangeError(const char* type,
359 Vector< Handle<Object> > args) {
360 return NewError("MakeRangeError", type, args);
361}
362
363
364Handle<Object> Factory::NewRangeError(Handle<String> message) {
365 return NewError("$RangeError", message);
366}
367
368
369Handle<Object> Factory::NewSyntaxError(const char* type, Handle<JSArray> args) {
370 return NewError("MakeSyntaxError", type, args);
371}
372
373
374Handle<Object> Factory::NewSyntaxError(Handle<String> message) {
375 return NewError("$SyntaxError", message);
376}
377
378
379Handle<Object> Factory::NewReferenceError(const char* type,
380 Vector< Handle<Object> > args) {
381 return NewError("MakeReferenceError", type, args);
382}
383
384
385Handle<Object> Factory::NewReferenceError(Handle<String> message) {
386 return NewError("$ReferenceError", message);
387}
388
389
390Handle<Object> Factory::NewError(const char* maker, const char* type,
391 Vector< Handle<Object> > args) {
ager@chromium.orgddb913d2009-01-27 10:01:48 +0000392 v8::HandleScope scope; // Instantiate a closeable HandleScope for EscapeFrom.
ager@chromium.org7c537e22008-10-16 08:43:32 +0000393 Handle<FixedArray> array = Factory::NewFixedArray(args.length());
394 for (int i = 0; i < args.length(); i++) {
395 array->set(i, *args[i]);
396 }
397 Handle<JSArray> object = Factory::NewJSArrayWithElements(array);
398 Handle<Object> result = NewError(maker, type, object);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000399 return result.EscapeFrom(&scope);
400}
401
402
403Handle<Object> Factory::NewEvalError(const char* type,
404 Vector< Handle<Object> > args) {
405 return NewError("MakeEvalError", type, args);
406}
407
408
409Handle<Object> Factory::NewError(const char* type,
410 Vector< Handle<Object> > args) {
411 return NewError("MakeError", type, args);
412}
413
414
415Handle<Object> Factory::NewError(const char* maker,
416 const char* type,
417 Handle<JSArray> args) {
418 Handle<String> make_str = Factory::LookupAsciiSymbol(maker);
ager@chromium.org4af710e2009-09-15 12:20:11 +0000419 Handle<Object> fun_obj(Top::builtins()->GetProperty(*make_str));
420 // If the builtins haven't been properly configured yet this error
421 // constructor may not have been defined. Bail out.
422 if (!fun_obj->IsJSFunction())
423 return Factory::undefined_value();
424 Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000425 Handle<Object> type_obj = Factory::LookupAsciiSymbol(type);
426 Object** argv[2] = { type_obj.location(),
427 Handle<Object>::cast(args).location() };
428
429 // Invoke the JavaScript factory method. If an exception is thrown while
430 // running the factory method, use the exception as the result.
431 bool caught_exception;
432 Handle<Object> result = Execution::TryCall(fun,
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000433 Top::builtins(),
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000434 2,
435 argv,
436 &caught_exception);
437 return result;
438}
439
440
441Handle<Object> Factory::NewError(Handle<String> message) {
442 return NewError("$Error", message);
443}
444
445
446Handle<Object> Factory::NewError(const char* constructor,
447 Handle<String> message) {
448 Handle<String> constr = Factory::LookupAsciiSymbol(constructor);
449 Handle<JSFunction> fun =
450 Handle<JSFunction>(
451 JSFunction::cast(
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000452 Top::builtins()->GetProperty(*constr)));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000453 Object** argv[1] = { Handle<Object>::cast(message).location() };
454
455 // Invoke the JavaScript factory method. If an exception is thrown while
456 // running the factory method, use the exception as the result.
457 bool caught_exception;
458 Handle<Object> result = Execution::TryCall(fun,
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000459 Top::builtins(),
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000460 1,
461 argv,
462 &caught_exception);
463 return result;
464}
465
466
467Handle<JSFunction> Factory::NewFunction(Handle<String> name,
468 InstanceType type,
469 int instance_size,
470 Handle<Code> code,
471 bool force_initial_map) {
472 // Allocate the function
473 Handle<JSFunction> function = NewFunction(name, the_hole_value());
474 function->set_code(*code);
475
476 if (force_initial_map ||
477 type != JS_OBJECT_TYPE ||
478 instance_size != JSObject::kHeaderSize) {
479 Handle<Map> initial_map = NewMap(type, instance_size);
480 Handle<JSObject> prototype = NewFunctionPrototype(function);
481 initial_map->set_prototype(*prototype);
482 function->set_initial_map(*initial_map);
483 initial_map->set_constructor(*function);
484 } else {
485 ASSERT(!function->has_initial_map());
486 ASSERT(!function->has_prototype());
487 }
488
489 return function;
490}
491
492
493Handle<JSFunction> Factory::NewFunctionBoilerplate(Handle<String> name,
494 int number_of_literals,
495 Handle<Code> code) {
496 Handle<JSFunction> function = NewFunctionBoilerplate(name);
497 function->set_code(*code);
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000498 int literals_array_size = number_of_literals;
499 // If the function contains object, regexp or array literals,
500 // allocate extra space for a literals array prefix containing the
501 // object, regexp and array constructor functions.
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +0000502 if (number_of_literals > 0) {
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000503 literals_array_size += JSFunction::kLiteralsPrefixSize;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000504 }
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000505 Handle<FixedArray> literals =
506 Factory::NewFixedArray(literals_array_size, TENURED);
507 function->set_literals(*literals);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000508 ASSERT(!function->has_initial_map());
509 ASSERT(!function->has_prototype());
510 return function;
511}
512
513
514Handle<JSFunction> Factory::NewFunctionBoilerplate(Handle<String> name) {
515 Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(name);
516 CALL_HEAP_FUNCTION(Heap::AllocateFunction(Heap::boilerplate_function_map(),
517 *shared,
518 Heap::the_hole_value()),
519 JSFunction);
520}
521
522
523Handle<JSFunction> Factory::NewFunctionWithPrototype(Handle<String> name,
524 InstanceType type,
525 int instance_size,
526 Handle<JSObject> prototype,
527 Handle<Code> code,
528 bool force_initial_map) {
529 // Allocate the function
530 Handle<JSFunction> function = NewFunction(name, prototype);
531
532 function->set_code(*code);
533
534 if (force_initial_map ||
535 type != JS_OBJECT_TYPE ||
536 instance_size != JSObject::kHeaderSize) {
537 Handle<Map> initial_map = NewMap(type, instance_size);
538 function->set_initial_map(*initial_map);
539 initial_map->set_constructor(*function);
540 }
541
542 // Set function.prototype and give the prototype a constructor
543 // property that refers to the function.
544 SetPrototypeProperty(function, prototype);
545 SetProperty(prototype, Factory::constructor_symbol(), function, DONT_ENUM);
546 return function;
547}
548
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000549
kasperl@chromium.org71affb52009-05-26 05:44:31 +0000550Handle<Code> Factory::NewCode(const CodeDesc& desc,
551 ZoneScopeInfo* sinfo,
552 Code::Flags flags,
553 Handle<Object> self_ref) {
kasperl@chromium.org061ef742009-02-27 12:16:20 +0000554 CALL_HEAP_FUNCTION(Heap::CreateCode(desc, sinfo, flags, self_ref), Code);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000555}
556
557
558Handle<Code> Factory::CopyCode(Handle<Code> code) {
559 CALL_HEAP_FUNCTION(Heap::CopyCode(*code), Code);
560}
561
562
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000563static inline Object* DoCopyInsert(DescriptorArray* array,
564 String* key,
565 Object* value,
566 PropertyAttributes attributes) {
567 CallbacksDescriptor desc(key, value, attributes);
568 Object* obj = array->CopyInsert(&desc, REMOVE_TRANSITIONS);
569 return obj;
570}
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000571
572
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000573// Allocate the new array.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000574Handle<DescriptorArray> Factory::CopyAppendProxyDescriptor(
575 Handle<DescriptorArray> array,
576 Handle<String> key,
577 Handle<Object> value,
578 PropertyAttributes attributes) {
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000579 CALL_HEAP_FUNCTION(DoCopyInsert(*array, *key, *value, attributes),
580 DescriptorArray);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000581}
582
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000583
584Handle<String> Factory::SymbolFromString(Handle<String> value) {
585 CALL_HEAP_FUNCTION(Heap::LookupSymbol(*value), String);
586}
587
588
589Handle<DescriptorArray> Factory::CopyAppendCallbackDescriptors(
590 Handle<DescriptorArray> array,
591 Handle<Object> descriptors) {
592 v8::NeanderArray callbacks(descriptors);
593 int nof_callbacks = callbacks.length();
594 Handle<DescriptorArray> result =
595 NewDescriptorArray(array->number_of_descriptors() + nof_callbacks);
596
597 // Number of descriptors added to the result so far.
598 int descriptor_count = 0;
599
600 // Copy the descriptors from the array.
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000601 for (int i = 0; i < array->number_of_descriptors(); i++) {
602 if (array->GetType(i) != NULL_DESCRIPTOR) {
603 result->CopyFrom(descriptor_count++, *array, i);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000604 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000605 }
606
607 // Number of duplicates detected.
608 int duplicates = 0;
609
610 // Fill in new callback descriptors. Process the callbacks from
611 // back to front so that the last callback with a given name takes
612 // precedence over previously added callbacks with that name.
613 for (int i = nof_callbacks - 1; i >= 0; i--) {
614 Handle<AccessorInfo> entry =
615 Handle<AccessorInfo>(AccessorInfo::cast(callbacks.get(i)));
616 // Ensure the key is a symbol before writing into the instance descriptor.
617 Handle<String> key =
618 SymbolFromString(Handle<String>(String::cast(entry->name())));
619 // Check if a descriptor with this name already exists before writing.
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +0000620 if (result->LinearSearch(*key, descriptor_count) ==
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000621 DescriptorArray::kNotFound) {
622 CallbacksDescriptor desc(*key, *entry, entry->property_attributes());
kasperl@chromium.org68ac0092009-07-09 06:00:35 +0000623 result->Set(descriptor_count, &desc);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000624 descriptor_count++;
625 } else {
626 duplicates++;
627 }
628 }
629
630 // If duplicates were detected, allocate a result of the right size
631 // and transfer the elements.
632 if (duplicates > 0) {
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000633 int number_of_descriptors = result->number_of_descriptors() - duplicates;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000634 Handle<DescriptorArray> new_result =
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000635 NewDescriptorArray(number_of_descriptors);
636 for (int i = 0; i < number_of_descriptors; i++) {
637 new_result->CopyFrom(i, *result, i);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000638 }
639 result = new_result;
640 }
641
642 // Sort the result before returning.
643 result->Sort();
644 return result;
645}
646
647
648Handle<JSObject> Factory::NewJSObject(Handle<JSFunction> constructor,
649 PretenureFlag pretenure) {
650 CALL_HEAP_FUNCTION(Heap::AllocateJSObject(*constructor, pretenure), JSObject);
651}
652
653
kasperl@chromium.org2abc4502009-07-02 07:00:29 +0000654Handle<GlobalObject> Factory::NewGlobalObject(
655 Handle<JSFunction> constructor) {
656 CALL_HEAP_FUNCTION(Heap::AllocateGlobalObject(*constructor),
657 GlobalObject);
658}
659
660
661
ager@chromium.org236ad962008-09-25 09:45:57 +0000662Handle<JSObject> Factory::NewJSObjectFromMap(Handle<Map> map) {
663 CALL_HEAP_FUNCTION(Heap::AllocateJSObjectFromMap(*map, NOT_TENURED),
664 JSObject);
665}
666
667
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000668Handle<JSArray> Factory::NewJSArray(int length,
669 PretenureFlag pretenure) {
670 Handle<JSObject> obj = NewJSObject(Top::array_function(), pretenure);
671 CALL_HEAP_FUNCTION(Handle<JSArray>::cast(obj)->Initialize(length), JSArray);
672}
673
674
675Handle<JSArray> Factory::NewJSArrayWithElements(Handle<FixedArray> elements,
676 PretenureFlag pretenure) {
677 Handle<JSArray> result =
678 Handle<JSArray>::cast(NewJSObject(Top::array_function(), pretenure));
679 result->SetContent(*elements);
680 return result;
681}
682
683
684Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(Handle<String> name) {
685 CALL_HEAP_FUNCTION(Heap::AllocateSharedFunctionInfo(*name),
686 SharedFunctionInfo);
687}
688
689
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +0000690Handle<String> Factory::NumberToString(Handle<Object> number) {
691 CALL_HEAP_FUNCTION(Heap::NumberToString(*number), String);
692}
693
694
kasperl@chromium.org86f77b72009-07-06 08:21:57 +0000695Handle<NumberDictionary> Factory::DictionaryAtNumberPut(
696 Handle<NumberDictionary> dictionary,
697 uint32_t key,
698 Handle<Object> value) {
699 CALL_HEAP_FUNCTION(dictionary->AtNumberPut(key, *value), NumberDictionary);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000700}
701
702
703Handle<JSFunction> Factory::NewFunctionHelper(Handle<String> name,
704 Handle<Object> prototype) {
705 Handle<SharedFunctionInfo> function_share = NewSharedFunctionInfo(name);
706 CALL_HEAP_FUNCTION(Heap::AllocateFunction(*Top::function_map(),
707 *function_share,
708 *prototype),
709 JSFunction);
710}
711
712
713Handle<JSFunction> Factory::NewFunction(Handle<String> name,
714 Handle<Object> prototype) {
715 Handle<JSFunction> fun = NewFunctionHelper(name, prototype);
716 fun->set_context(Top::context()->global_context());
717 return fun;
718}
719
720
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000721Handle<Object> Factory::ToObject(Handle<Object> object) {
722 CALL_HEAP_FUNCTION(object->ToObject(), Object);
723}
724
725
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000726Handle<Object> Factory::ToObject(Handle<Object> object,
727 Handle<Context> global_context) {
728 CALL_HEAP_FUNCTION(object->ToObject(*global_context), Object);
729}
730
731
ager@chromium.org65dad4b2009-04-23 08:48:43 +0000732#ifdef ENABLE_DEBUGGER_SUPPORT
v8.team.kasperl727e9952008-09-02 14:56:44 +0000733Handle<DebugInfo> Factory::NewDebugInfo(Handle<SharedFunctionInfo> shared) {
734 // Get the original code of the function.
735 Handle<Code> code(shared->code());
736
737 // Create a copy of the code before allocating the debug info object to avoid
738 // allocation while setting up the debug info object.
739 Handle<Code> original_code(*Factory::CopyCode(code));
740
741 // Allocate initial fixed array for active break points before allocating the
742 // debug info object to avoid allocation while setting up the debug info
743 // object.
744 Handle<FixedArray> break_points(
745 Factory::NewFixedArray(Debug::kEstimatedNofBreakPointsInFunction));
746
747 // Create and set up the debug info object. Debug info contains function, a
748 // copy of the original code, the executing code and initial fixed array for
749 // active break points.
750 Handle<DebugInfo> debug_info =
751 Handle<DebugInfo>::cast(Factory::NewStruct(DEBUG_INFO_TYPE));
752 debug_info->set_shared(*shared);
753 debug_info->set_original_code(*original_code);
754 debug_info->set_code(*code);
755 debug_info->set_break_points(*break_points);
756
757 // Link debug info to function.
758 shared->set_debug_info(*debug_info);
759
760 return debug_info;
761}
ager@chromium.org65dad4b2009-04-23 08:48:43 +0000762#endif
v8.team.kasperl727e9952008-09-02 14:56:44 +0000763
764
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000765Handle<JSObject> Factory::NewArgumentsObject(Handle<Object> callee,
766 int length) {
767 CALL_HEAP_FUNCTION(Heap::AllocateArgumentsObject(*callee, length), JSObject);
768}
769
770
771Handle<JSFunction> Factory::CreateApiFunction(
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000772 Handle<FunctionTemplateInfo> obj, ApiInstanceType instance_type) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000773 Handle<Code> code = Handle<Code>(Builtins::builtin(Builtins::HandleApiCall));
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000774 Handle<Code> construct_stub =
775 Handle<Code>(Builtins::builtin(Builtins::JSConstructStubApi));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000776
kasper.lund212ac232008-07-16 07:07:30 +0000777 int internal_field_count = 0;
778 if (!obj->instance_template()->IsUndefined()) {
779 Handle<ObjectTemplateInfo> instance_template =
780 Handle<ObjectTemplateInfo>(
781 ObjectTemplateInfo::cast(obj->instance_template()));
782 internal_field_count =
783 Smi::cast(instance_template->internal_field_count())->value();
784 }
785
786 int instance_size = kPointerSize * internal_field_count;
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +0000787 InstanceType type = INVALID_TYPE;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000788 switch (instance_type) {
789 case JavaScriptObject:
790 type = JS_OBJECT_TYPE;
791 instance_size += JSObject::kHeaderSize;
792 break;
793 case InnerGlobalObject:
794 type = JS_GLOBAL_OBJECT_TYPE;
795 instance_size += JSGlobalObject::kSize;
796 break;
797 case OuterGlobalObject:
798 type = JS_GLOBAL_PROXY_TYPE;
799 instance_size += JSGlobalProxy::kSize;
800 break;
801 default:
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000802 break;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000803 }
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +0000804 ASSERT(type != INVALID_TYPE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000805
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000806 Handle<JSFunction> result =
ager@chromium.orga74f0da2008-12-03 16:05:52 +0000807 Factory::NewFunction(Factory::empty_symbol(),
808 type,
809 instance_size,
810 code,
811 true);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000812 // Set class name.
813 Handle<Object> class_name = Handle<Object>(obj->class_name());
814 if (class_name->IsString()) {
815 result->shared()->set_instance_class_name(*class_name);
816 result->shared()->set_name(*class_name);
817 }
818
819 Handle<Map> map = Handle<Map>(result->initial_map());
820
821 // Mark as undetectable if needed.
822 if (obj->undetectable()) {
823 map->set_is_undetectable();
824 }
825
826 // Mark as hidden for the __proto__ accessor if needed.
827 if (obj->hidden_prototype()) {
828 map->set_is_hidden_prototype();
829 }
830
831 // Mark as needs_access_check if needed.
832 if (obj->needs_access_check()) {
ager@chromium.org870a0b62008-11-04 11:43:05 +0000833 map->set_is_access_check_needed(true);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000834 }
835
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000836 // Set interceptor information in the map.
837 if (!obj->named_property_handler()->IsUndefined()) {
838 map->set_has_named_interceptor();
839 }
840 if (!obj->indexed_property_handler()->IsUndefined()) {
841 map->set_has_indexed_interceptor();
842 }
843
844 // Set instance call-as-function information in the map.
845 if (!obj->instance_call_handler()->IsUndefined()) {
846 map->set_has_instance_call_handler();
847 }
848
849 result->shared()->set_function_data(*obj);
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000850 result->shared()->set_construct_stub(*construct_stub);
kasperl@chromium.orgb9123622008-09-17 14:05:56 +0000851 result->shared()->DontAdaptArguments();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000852
853 // Recursively copy parent templates' accessors, 'data' may be modified.
854 Handle<DescriptorArray> array =
855 Handle<DescriptorArray>(map->instance_descriptors());
856 while (true) {
857 Handle<Object> props = Handle<Object>(obj->property_accessors());
858 if (!props->IsUndefined()) {
859 array = Factory::CopyAppendCallbackDescriptors(array, props);
860 }
861 Handle<Object> parent = Handle<Object>(obj->parent_template());
862 if (parent->IsUndefined()) break;
863 obj = Handle<FunctionTemplateInfo>::cast(parent);
864 }
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000865 if (!array->IsEmpty()) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000866 map->set_instance_descriptors(*array);
867 }
868
869 return result;
870}
871
872
ager@chromium.org236ad962008-09-25 09:45:57 +0000873Handle<MapCache> Factory::NewMapCache(int at_least_space_for) {
874 CALL_HEAP_FUNCTION(MapCache::Allocate(at_least_space_for), MapCache);
875}
876
877
878static Object* UpdateMapCacheWith(Context* context,
879 FixedArray* keys,
880 Map* map) {
881 Object* result = MapCache::cast(context->map_cache())->Put(keys, map);
882 if (!result->IsFailure()) context->set_map_cache(MapCache::cast(result));
883 return result;
884}
885
886
887Handle<MapCache> Factory::AddToMapCache(Handle<Context> context,
888 Handle<FixedArray> keys,
889 Handle<Map> map) {
890 CALL_HEAP_FUNCTION(UpdateMapCacheWith(*context, *keys, *map), MapCache);
891}
892
893
894Handle<Map> Factory::ObjectLiteralMapFromCache(Handle<Context> context,
895 Handle<FixedArray> keys) {
896 if (context->map_cache()->IsUndefined()) {
897 // Allocate the new map cache for the global context.
898 Handle<MapCache> new_cache = NewMapCache(24);
899 context->set_map_cache(*new_cache);
900 }
ager@chromium.org32912102009-01-16 10:38:43 +0000901 // Check to see whether there is a matching element in the cache.
ager@chromium.org236ad962008-09-25 09:45:57 +0000902 Handle<MapCache> cache =
903 Handle<MapCache>(MapCache::cast(context->map_cache()));
904 Handle<Object> result = Handle<Object>(cache->Lookup(*keys));
905 if (result->IsMap()) return Handle<Map>::cast(result);
906 // Create a new map and add it to the cache.
907 Handle<Map> map =
ager@chromium.org32912102009-01-16 10:38:43 +0000908 CopyMap(Handle<Map>(context->object_function()->initial_map()),
909 keys->length());
ager@chromium.org236ad962008-09-25 09:45:57 +0000910 AddToMapCache(context, keys, map);
911 return Handle<Map>(map);
912}
913
914
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000915void Factory::SetRegExpAtomData(Handle<JSRegExp> regexp,
916 JSRegExp::Type type,
917 Handle<String> source,
918 JSRegExp::Flags flags,
919 Handle<Object> data) {
920 Handle<FixedArray> store = NewFixedArray(JSRegExp::kAtomDataSize);
921
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +0000922 store->set(JSRegExp::kTagIndex, Smi::FromInt(type));
923 store->set(JSRegExp::kSourceIndex, *source);
924 store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value()));
925 store->set(JSRegExp::kAtomPatternIndex, *data);
926 regexp->set_data(*store);
927}
928
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000929void Factory::SetRegExpIrregexpData(Handle<JSRegExp> regexp,
930 JSRegExp::Type type,
931 Handle<String> source,
932 JSRegExp::Flags flags,
933 int capture_count) {
934 Handle<FixedArray> store = NewFixedArray(JSRegExp::kIrregexpDataSize);
935
936 store->set(JSRegExp::kTagIndex, Smi::FromInt(type));
937 store->set(JSRegExp::kSourceIndex, *source);
938 store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value()));
939 store->set(JSRegExp::kIrregexpASCIICodeIndex, Heap::the_hole_value());
940 store->set(JSRegExp::kIrregexpUC16CodeIndex, Heap::the_hole_value());
941 store->set(JSRegExp::kIrregexpMaxRegisterCountIndex, Smi::FromInt(0));
942 store->set(JSRegExp::kIrregexpCaptureCountIndex,
943 Smi::FromInt(capture_count));
944 regexp->set_data(*store);
945}
946
947
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +0000948
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000949void Factory::ConfigureInstance(Handle<FunctionTemplateInfo> desc,
950 Handle<JSObject> instance,
951 bool* pending_exception) {
952 // Configure the instance by adding the properties specified by the
953 // instance template.
954 Handle<Object> instance_template = Handle<Object>(desc->instance_template());
955 if (!instance_template->IsUndefined()) {
956 Execution::ConfigureInstance(instance,
957 instance_template,
958 pending_exception);
959 } else {
960 *pending_exception = false;
961 }
962}
963
964
965} } // namespace v8::internal