1 // Copyright 2013 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 #include "v8.h" 29 30 #include "api.h" 31 #include "debug.h" 32 #include "execution.h" 33 #include "factory.h" 34 #include "isolate-inl.h" 35 #include "macro-assembler.h" 36 #include "objects.h" 37 #include "objects-visiting.h" 38 #include "platform.h" 39 #include "scopeinfo.h" 40 41 namespace v8 { 42 namespace internal { 43 44 45 Handle<Box> Factory::NewBox(Handle<Object> value, PretenureFlag pretenure) { 46 CALL_HEAP_FUNCTION( 47 isolate(), 48 isolate()->heap()->AllocateBox(*value, pretenure), 49 Box); 50 } 51 52 53 Handle<FixedArray> Factory::NewFixedArray(int size, PretenureFlag pretenure) { 54 ASSERT(0 <= size); 55 CALL_HEAP_FUNCTION( 56 isolate(), 57 isolate()->heap()->AllocateFixedArray(size, pretenure), 58 FixedArray); 59 } 60 61 62 Handle<FixedArray> Factory::NewFixedArrayWithHoles(int size, 63 PretenureFlag pretenure) { 64 ASSERT(0 <= size); 65 CALL_HEAP_FUNCTION( 66 isolate(), 67 isolate()->heap()->AllocateFixedArrayWithHoles(size, pretenure), 68 FixedArray); 69 } 70 71 72 Handle<FixedDoubleArray> Factory::NewFixedDoubleArray(int size, 73 PretenureFlag pretenure) { 74 ASSERT(0 <= size); 75 CALL_HEAP_FUNCTION( 76 isolate(), 77 isolate()->heap()->AllocateUninitializedFixedDoubleArray(size, pretenure), 78 FixedDoubleArray); 79 } 80 81 82 Handle<NameDictionary> Factory::NewNameDictionary(int at_least_space_for) { 83 ASSERT(0 <= at_least_space_for); 84 CALL_HEAP_FUNCTION(isolate(), 85 NameDictionary::Allocate(isolate()->heap(), 86 at_least_space_for), 87 NameDictionary); 88 } 89 90 91 Handle<SeededNumberDictionary> Factory::NewSeededNumberDictionary( 92 int at_least_space_for) { 93 ASSERT(0 <= at_least_space_for); 94 CALL_HEAP_FUNCTION(isolate(), 95 SeededNumberDictionary::Allocate(isolate()->heap(), 96 at_least_space_for), 97 SeededNumberDictionary); 98 } 99 100 101 Handle<UnseededNumberDictionary> Factory::NewUnseededNumberDictionary( 102 int at_least_space_for) { 103 ASSERT(0 <= at_least_space_for); 104 CALL_HEAP_FUNCTION(isolate(), 105 UnseededNumberDictionary::Allocate(isolate()->heap(), 106 at_least_space_for), 107 UnseededNumberDictionary); 108 } 109 110 111 Handle<ObjectHashSet> Factory::NewObjectHashSet(int at_least_space_for) { 112 ASSERT(0 <= at_least_space_for); 113 CALL_HEAP_FUNCTION(isolate(), 114 ObjectHashSet::Allocate(isolate()->heap(), 115 at_least_space_for), 116 ObjectHashSet); 117 } 118 119 120 Handle<ObjectHashTable> Factory::NewObjectHashTable(int at_least_space_for) { 121 ASSERT(0 <= at_least_space_for); 122 CALL_HEAP_FUNCTION(isolate(), 123 ObjectHashTable::Allocate(isolate()->heap(), 124 at_least_space_for), 125 ObjectHashTable); 126 } 127 128 129 Handle<DescriptorArray> Factory::NewDescriptorArray(int number_of_descriptors, 130 int slack) { 131 ASSERT(0 <= number_of_descriptors); 132 CALL_HEAP_FUNCTION(isolate(), 133 DescriptorArray::Allocate(number_of_descriptors, slack), 134 DescriptorArray); 135 } 136 137 138 Handle<DeoptimizationInputData> Factory::NewDeoptimizationInputData( 139 int deopt_entry_count, 140 PretenureFlag pretenure) { 141 ASSERT(deopt_entry_count > 0); 142 CALL_HEAP_FUNCTION(isolate(), 143 DeoptimizationInputData::Allocate(deopt_entry_count, 144 pretenure), 145 DeoptimizationInputData); 146 } 147 148 149 Handle<DeoptimizationOutputData> Factory::NewDeoptimizationOutputData( 150 int deopt_entry_count, 151 PretenureFlag pretenure) { 152 ASSERT(deopt_entry_count > 0); 153 CALL_HEAP_FUNCTION(isolate(), 154 DeoptimizationOutputData::Allocate(deopt_entry_count, 155 pretenure), 156 DeoptimizationOutputData); 157 } 158 159 160 Handle<AccessorPair> Factory::NewAccessorPair() { 161 CALL_HEAP_FUNCTION(isolate(), 162 isolate()->heap()->AllocateAccessorPair(), 163 AccessorPair); 164 } 165 166 167 Handle<TypeFeedbackInfo> Factory::NewTypeFeedbackInfo() { 168 CALL_HEAP_FUNCTION(isolate(), 169 isolate()->heap()->AllocateTypeFeedbackInfo(), 170 TypeFeedbackInfo); 171 } 172 173 174 // Internalized strings are created in the old generation (data space). 175 Handle<String> Factory::InternalizeUtf8String(Vector<const char> string) { 176 CALL_HEAP_FUNCTION(isolate(), 177 isolate()->heap()->InternalizeUtf8String(string), 178 String); 179 } 180 181 182 // Internalized strings are created in the old generation (data space). 183 Handle<String> Factory::InternalizeString(Handle<String> string) { 184 CALL_HEAP_FUNCTION(isolate(), 185 isolate()->heap()->InternalizeString(*string), 186 String); 187 } 188 189 190 Handle<String> Factory::InternalizeOneByteString(Vector<const uint8_t> string) { 191 CALL_HEAP_FUNCTION(isolate(), 192 isolate()->heap()->InternalizeOneByteString(string), 193 String); 194 } 195 196 197 Handle<String> Factory::InternalizeOneByteString( 198 Handle<SeqOneByteString> string, int from, int length) { 199 CALL_HEAP_FUNCTION(isolate(), 200 isolate()->heap()->InternalizeOneByteString( 201 string, from, length), 202 String); 203 } 204 205 206 Handle<String> Factory::InternalizeTwoByteString(Vector<const uc16> string) { 207 CALL_HEAP_FUNCTION(isolate(), 208 isolate()->heap()->InternalizeTwoByteString(string), 209 String); 210 } 211 212 213 Handle<String> Factory::NewStringFromOneByte(Vector<const uint8_t> string, 214 PretenureFlag pretenure) { 215 CALL_HEAP_FUNCTION( 216 isolate(), 217 isolate()->heap()->AllocateStringFromOneByte(string, pretenure), 218 String); 219 } 220 221 Handle<String> Factory::NewStringFromUtf8(Vector<const char> string, 222 PretenureFlag pretenure) { 223 CALL_HEAP_FUNCTION( 224 isolate(), 225 isolate()->heap()->AllocateStringFromUtf8(string, pretenure), 226 String); 227 } 228 229 230 Handle<String> Factory::NewStringFromTwoByte(Vector<const uc16> string, 231 PretenureFlag pretenure) { 232 CALL_HEAP_FUNCTION( 233 isolate(), 234 isolate()->heap()->AllocateStringFromTwoByte(string, pretenure), 235 String); 236 } 237 238 239 Handle<SeqOneByteString> Factory::NewRawOneByteString(int length, 240 PretenureFlag pretenure) { 241 CALL_HEAP_FUNCTION( 242 isolate(), 243 isolate()->heap()->AllocateRawOneByteString(length, pretenure), 244 SeqOneByteString); 245 } 246 247 248 Handle<SeqTwoByteString> Factory::NewRawTwoByteString(int length, 249 PretenureFlag pretenure) { 250 CALL_HEAP_FUNCTION( 251 isolate(), 252 isolate()->heap()->AllocateRawTwoByteString(length, pretenure), 253 SeqTwoByteString); 254 } 255 256 257 Handle<String> Factory::NewConsString(Handle<String> first, 258 Handle<String> second) { 259 CALL_HEAP_FUNCTION(isolate(), 260 isolate()->heap()->AllocateConsString(*first, *second), 261 String); 262 } 263 264 265 template<typename SinkChar, typename StringType> 266 Handle<String> ConcatStringContent(Handle<StringType> result, 267 Handle<String> first, 268 Handle<String> second) { 269 DisallowHeapAllocation pointer_stays_valid; 270 SinkChar* sink = result->GetChars(); 271 String::WriteToFlat(*first, sink, 0, first->length()); 272 String::WriteToFlat(*second, sink + first->length(), 0, second->length()); 273 return result; 274 } 275 276 277 Handle<String> Factory::NewFlatConcatString(Handle<String> first, 278 Handle<String> second) { 279 int total_length = first->length() + second->length(); 280 if (first->IsOneByteRepresentationUnderneath() && 281 second->IsOneByteRepresentationUnderneath()) { 282 return ConcatStringContent<uint8_t>( 283 NewRawOneByteString(total_length), first, second); 284 } else { 285 return ConcatStringContent<uc16>( 286 NewRawTwoByteString(total_length), first, second); 287 } 288 } 289 290 291 Handle<String> Factory::NewSubString(Handle<String> str, 292 int begin, 293 int end) { 294 CALL_HEAP_FUNCTION(isolate(), 295 str->SubString(begin, end), 296 String); 297 } 298 299 300 Handle<String> Factory::NewProperSubString(Handle<String> str, 301 int begin, 302 int end) { 303 ASSERT(begin > 0 || end < str->length()); 304 CALL_HEAP_FUNCTION(isolate(), 305 isolate()->heap()->AllocateSubString(*str, begin, end), 306 String); 307 } 308 309 310 Handle<String> Factory::NewExternalStringFromAscii( 311 const ExternalAsciiString::Resource* resource) { 312 CALL_HEAP_FUNCTION( 313 isolate(), 314 isolate()->heap()->AllocateExternalStringFromAscii(resource), 315 String); 316 } 317 318 319 Handle<String> Factory::NewExternalStringFromTwoByte( 320 const ExternalTwoByteString::Resource* resource) { 321 CALL_HEAP_FUNCTION( 322 isolate(), 323 isolate()->heap()->AllocateExternalStringFromTwoByte(resource), 324 String); 325 } 326 327 328 Handle<Symbol> Factory::NewSymbol() { 329 CALL_HEAP_FUNCTION( 330 isolate(), 331 isolate()->heap()->AllocateSymbol(), 332 Symbol); 333 } 334 335 336 Handle<Context> Factory::NewNativeContext() { 337 CALL_HEAP_FUNCTION( 338 isolate(), 339 isolate()->heap()->AllocateNativeContext(), 340 Context); 341 } 342 343 344 Handle<Context> Factory::NewGlobalContext(Handle<JSFunction> function, 345 Handle<ScopeInfo> scope_info) { 346 CALL_HEAP_FUNCTION( 347 isolate(), 348 isolate()->heap()->AllocateGlobalContext(*function, *scope_info), 349 Context); 350 } 351 352 353 Handle<Context> Factory::NewModuleContext(Handle<ScopeInfo> scope_info) { 354 CALL_HEAP_FUNCTION( 355 isolate(), 356 isolate()->heap()->AllocateModuleContext(*scope_info), 357 Context); 358 } 359 360 361 Handle<Context> Factory::NewFunctionContext(int length, 362 Handle<JSFunction> function) { 363 CALL_HEAP_FUNCTION( 364 isolate(), 365 isolate()->heap()->AllocateFunctionContext(length, *function), 366 Context); 367 } 368 369 370 Handle<Context> Factory::NewCatchContext(Handle<JSFunction> function, 371 Handle<Context> previous, 372 Handle<String> name, 373 Handle<Object> thrown_object) { 374 CALL_HEAP_FUNCTION( 375 isolate(), 376 isolate()->heap()->AllocateCatchContext(*function, 377 *previous, 378 *name, 379 *thrown_object), 380 Context); 381 } 382 383 384 Handle<Context> Factory::NewWithContext(Handle<JSFunction> function, 385 Handle<Context> previous, 386 Handle<JSObject> extension) { 387 CALL_HEAP_FUNCTION( 388 isolate(), 389 isolate()->heap()->AllocateWithContext(*function, *previous, *extension), 390 Context); 391 } 392 393 394 Handle<Context> Factory::NewBlockContext(Handle<JSFunction> function, 395 Handle<Context> previous, 396 Handle<ScopeInfo> scope_info) { 397 CALL_HEAP_FUNCTION( 398 isolate(), 399 isolate()->heap()->AllocateBlockContext(*function, 400 *previous, 401 *scope_info), 402 Context); 403 } 404 405 406 Handle<Struct> Factory::NewStruct(InstanceType type) { 407 CALL_HEAP_FUNCTION( 408 isolate(), 409 isolate()->heap()->AllocateStruct(type), 410 Struct); 411 } 412 413 414 Handle<DeclaredAccessorDescriptor> Factory::NewDeclaredAccessorDescriptor() { 415 return Handle<DeclaredAccessorDescriptor>::cast( 416 NewStruct(DECLARED_ACCESSOR_DESCRIPTOR_TYPE)); 417 } 418 419 420 Handle<DeclaredAccessorInfo> Factory::NewDeclaredAccessorInfo() { 421 Handle<DeclaredAccessorInfo> info = 422 Handle<DeclaredAccessorInfo>::cast( 423 NewStruct(DECLARED_ACCESSOR_INFO_TYPE)); 424 info->set_flag(0); // Must clear the flag, it was initialized as undefined. 425 return info; 426 } 427 428 429 Handle<ExecutableAccessorInfo> Factory::NewExecutableAccessorInfo() { 430 Handle<ExecutableAccessorInfo> info = 431 Handle<ExecutableAccessorInfo>::cast( 432 NewStruct(EXECUTABLE_ACCESSOR_INFO_TYPE)); 433 info->set_flag(0); // Must clear the flag, it was initialized as undefined. 434 return info; 435 } 436 437 438 Handle<Script> Factory::NewScript(Handle<String> source) { 439 // Generate id for this script. 440 Heap* heap = isolate()->heap(); 441 int id = heap->last_script_id()->value() + 1; 442 if (!Smi::IsValid(id) || id < 0) id = 1; 443 heap->set_last_script_id(Smi::FromInt(id)); 444 445 // Create and initialize script object. 446 Handle<Foreign> wrapper = NewForeign(0, TENURED); 447 Handle<Script> script = Handle<Script>::cast(NewStruct(SCRIPT_TYPE)); 448 script->set_source(*source); 449 script->set_name(heap->undefined_value()); 450 script->set_id(Smi::FromInt(id)); 451 script->set_line_offset(Smi::FromInt(0)); 452 script->set_column_offset(Smi::FromInt(0)); 453 script->set_data(heap->undefined_value()); 454 script->set_context_data(heap->undefined_value()); 455 script->set_type(Smi::FromInt(Script::TYPE_NORMAL)); 456 script->set_wrapper(*wrapper); 457 script->set_line_ends(heap->undefined_value()); 458 script->set_eval_from_shared(heap->undefined_value()); 459 script->set_eval_from_instructions_offset(Smi::FromInt(0)); 460 script->set_flags(Smi::FromInt(0)); 461 462 return script; 463 } 464 465 466 Handle<Foreign> Factory::NewForeign(Address addr, PretenureFlag pretenure) { 467 CALL_HEAP_FUNCTION(isolate(), 468 isolate()->heap()->AllocateForeign(addr, pretenure), 469 Foreign); 470 } 471 472 473 Handle<Foreign> Factory::NewForeign(const AccessorDescriptor* desc) { 474 return NewForeign((Address) desc, TENURED); 475 } 476 477 478 Handle<ByteArray> Factory::NewByteArray(int length, PretenureFlag pretenure) { 479 ASSERT(0 <= length); 480 CALL_HEAP_FUNCTION( 481 isolate(), 482 isolate()->heap()->AllocateByteArray(length, pretenure), 483 ByteArray); 484 } 485 486 487 Handle<ExternalArray> Factory::NewExternalArray(int length, 488 ExternalArrayType array_type, 489 void* external_pointer, 490 PretenureFlag pretenure) { 491 ASSERT(0 <= length); 492 CALL_HEAP_FUNCTION( 493 isolate(), 494 isolate()->heap()->AllocateExternalArray(length, 495 array_type, 496 external_pointer, 497 pretenure), 498 ExternalArray); 499 } 500 501 502 Handle<Cell> Factory::NewCell(Handle<Object> value) { 503 AllowDeferredHandleDereference convert_to_cell; 504 CALL_HEAP_FUNCTION( 505 isolate(), 506 isolate()->heap()->AllocateCell(*value), 507 Cell); 508 } 509 510 511 Handle<PropertyCell> Factory::NewPropertyCell(Handle<Object> value) { 512 AllowDeferredHandleDereference convert_to_cell; 513 CALL_HEAP_FUNCTION( 514 isolate(), 515 isolate()->heap()->AllocatePropertyCell(*value), 516 PropertyCell); 517 } 518 519 520 Handle<AllocationSite> Factory::NewAllocationSite() { 521 CALL_HEAP_FUNCTION( 522 isolate(), 523 isolate()->heap()->AllocateAllocationSite(), 524 AllocationSite); 525 } 526 527 528 Handle<Map> Factory::NewMap(InstanceType type, 529 int instance_size, 530 ElementsKind elements_kind) { 531 CALL_HEAP_FUNCTION( 532 isolate(), 533 isolate()->heap()->AllocateMap(type, instance_size, elements_kind), 534 Map); 535 } 536 537 538 Handle<JSObject> Factory::NewFunctionPrototype(Handle<JSFunction> function) { 539 CALL_HEAP_FUNCTION( 540 isolate(), 541 isolate()->heap()->AllocateFunctionPrototype(*function), 542 JSObject); 543 } 544 545 546 Handle<Map> Factory::CopyWithPreallocatedFieldDescriptors(Handle<Map> src) { 547 CALL_HEAP_FUNCTION( 548 isolate(), src->CopyWithPreallocatedFieldDescriptors(), Map); 549 } 550 551 552 Handle<Map> Factory::CopyMap(Handle<Map> src, 553 int extra_inobject_properties) { 554 Handle<Map> copy = CopyWithPreallocatedFieldDescriptors(src); 555 // Check that we do not overflow the instance size when adding the 556 // extra inobject properties. 557 int instance_size_delta = extra_inobject_properties * kPointerSize; 558 int max_instance_size_delta = 559 JSObject::kMaxInstanceSize - copy->instance_size(); 560 if (instance_size_delta > max_instance_size_delta) { 561 // If the instance size overflows, we allocate as many properties 562 // as we can as inobject properties. 563 instance_size_delta = max_instance_size_delta; 564 extra_inobject_properties = max_instance_size_delta >> kPointerSizeLog2; 565 } 566 // Adjust the map with the extra inobject properties. 567 int inobject_properties = 568 copy->inobject_properties() + extra_inobject_properties; 569 copy->set_inobject_properties(inobject_properties); 570 copy->set_unused_property_fields(inobject_properties); 571 copy->set_instance_size(copy->instance_size() + instance_size_delta); 572 copy->set_visitor_id(StaticVisitorBase::GetVisitorId(*copy)); 573 return copy; 574 } 575 576 577 Handle<Map> Factory::CopyMap(Handle<Map> src) { 578 CALL_HEAP_FUNCTION(isolate(), src->Copy(), Map); 579 } 580 581 582 Handle<Map> Factory::GetElementsTransitionMap( 583 Handle<JSObject> src, 584 ElementsKind elements_kind) { 585 Isolate* i = isolate(); 586 CALL_HEAP_FUNCTION(i, 587 src->GetElementsTransitionMap(i, elements_kind), 588 Map); 589 } 590 591 592 Handle<FixedArray> Factory::CopyFixedArray(Handle<FixedArray> array) { 593 CALL_HEAP_FUNCTION(isolate(), array->Copy(), FixedArray); 594 } 595 596 597 Handle<FixedArray> Factory::CopySizeFixedArray(Handle<FixedArray> array, 598 int new_length) { 599 CALL_HEAP_FUNCTION(isolate(), array->CopySize(new_length), FixedArray); 600 } 601 602 603 Handle<FixedDoubleArray> Factory::CopyFixedDoubleArray( 604 Handle<FixedDoubleArray> array) { 605 CALL_HEAP_FUNCTION(isolate(), array->Copy(), FixedDoubleArray); 606 } 607 608 609 Handle<JSFunction> Factory::BaseNewFunctionFromSharedFunctionInfo( 610 Handle<SharedFunctionInfo> function_info, 611 Handle<Map> function_map, 612 PretenureFlag pretenure) { 613 CALL_HEAP_FUNCTION( 614 isolate(), 615 isolate()->heap()->AllocateFunction(*function_map, 616 *function_info, 617 isolate()->heap()->the_hole_value(), 618 pretenure), 619 JSFunction); 620 } 621 622 623 static Handle<Map> MapForNewFunction(Isolate *isolate, 624 Handle<SharedFunctionInfo> function_info) { 625 Context *context = isolate->context()->native_context(); 626 int map_index = Context::FunctionMapIndex(function_info->language_mode(), 627 function_info->is_generator()); 628 return Handle<Map>(Map::cast(context->get(map_index))); 629 } 630 631 632 Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo( 633 Handle<SharedFunctionInfo> function_info, 634 Handle<Context> context, 635 PretenureFlag pretenure) { 636 Handle<JSFunction> result = BaseNewFunctionFromSharedFunctionInfo( 637 function_info, 638 MapForNewFunction(isolate(), function_info), 639 pretenure); 640 641 if (function_info->ic_age() != isolate()->heap()->global_ic_age()) { 642 function_info->ResetForNewContext(isolate()->heap()->global_ic_age()); 643 } 644 645 result->set_context(*context); 646 647 int index = function_info->SearchOptimizedCodeMap(context->native_context()); 648 if (!function_info->bound() && index < 0) { 649 int number_of_literals = function_info->num_literals(); 650 Handle<FixedArray> literals = NewFixedArray(number_of_literals, pretenure); 651 if (number_of_literals > 0) { 652 // Store the native context in the literals array prefix. This 653 // context will be used when creating object, regexp and array 654 // literals in this function. 655 literals->set(JSFunction::kLiteralNativeContextIndex, 656 context->native_context()); 657 } 658 result->set_literals(*literals); 659 } 660 661 if (index > 0) { 662 // Caching of optimized code enabled and optimized code found. 663 function_info->InstallFromOptimizedCodeMap(*result, index); 664 return result; 665 } 666 667 if (V8::UseCrankshaft() && 668 FLAG_always_opt && 669 result->is_compiled() && 670 !function_info->is_toplevel() && 671 function_info->allows_lazy_compilation() && 672 !function_info->optimization_disabled() && 673 !isolate()->DebuggerHasBreakPoints()) { 674 result->MarkForLazyRecompilation(); 675 } 676 return result; 677 } 678 679 680 Handle<Object> Factory::NewNumber(double value, 681 PretenureFlag pretenure) { 682 CALL_HEAP_FUNCTION( 683 isolate(), 684 isolate()->heap()->NumberFromDouble(value, pretenure), Object); 685 } 686 687 688 Handle<Object> Factory::NewNumberFromInt(int32_t value, 689 PretenureFlag pretenure) { 690 CALL_HEAP_FUNCTION( 691 isolate(), 692 isolate()->heap()->NumberFromInt32(value, pretenure), Object); 693 } 694 695 696 Handle<Object> Factory::NewNumberFromUint(uint32_t value, 697 PretenureFlag pretenure) { 698 CALL_HEAP_FUNCTION( 699 isolate(), 700 isolate()->heap()->NumberFromUint32(value, pretenure), Object); 701 } 702 703 704 Handle<HeapNumber> Factory::NewHeapNumber(double value, 705 PretenureFlag pretenure) { 706 CALL_HEAP_FUNCTION( 707 isolate(), 708 isolate()->heap()->AllocateHeapNumber(value, pretenure), HeapNumber); 709 } 710 711 712 Handle<JSObject> Factory::NewNeanderObject() { 713 CALL_HEAP_FUNCTION( 714 isolate(), 715 isolate()->heap()->AllocateJSObjectFromMap( 716 isolate()->heap()->neander_map()), 717 JSObject); 718 } 719 720 721 Handle<Object> Factory::NewTypeError(const char* message, 722 Vector< Handle<Object> > args) { 723 return NewError("MakeTypeError", message, args); 724 } 725 726 727 Handle<Object> Factory::NewTypeError(Handle<String> message) { 728 return NewError("$TypeError", message); 729 } 730 731 732 Handle<Object> Factory::NewRangeError(const char* message, 733 Vector< Handle<Object> > args) { 734 return NewError("MakeRangeError", message, args); 735 } 736 737 738 Handle<Object> Factory::NewRangeError(Handle<String> message) { 739 return NewError("$RangeError", message); 740 } 741 742 743 Handle<Object> Factory::NewSyntaxError(const char* message, 744 Handle<JSArray> args) { 745 return NewError("MakeSyntaxError", message, args); 746 } 747 748 749 Handle<Object> Factory::NewSyntaxError(Handle<String> message) { 750 return NewError("$SyntaxError", message); 751 } 752 753 754 Handle<Object> Factory::NewReferenceError(const char* message, 755 Vector< Handle<Object> > args) { 756 return NewError("MakeReferenceError", message, args); 757 } 758 759 760 Handle<Object> Factory::NewReferenceError(Handle<String> message) { 761 return NewError("$ReferenceError", message); 762 } 763 764 765 Handle<Object> Factory::NewError(const char* maker, 766 const char* message, 767 Vector< Handle<Object> > args) { 768 // Instantiate a closeable HandleScope for EscapeFrom. 769 v8::HandleScope scope(reinterpret_cast<v8::Isolate*>(isolate())); 770 Handle<FixedArray> array = NewFixedArray(args.length()); 771 for (int i = 0; i < args.length(); i++) { 772 array->set(i, *args[i]); 773 } 774 Handle<JSArray> object = NewJSArrayWithElements(array); 775 Handle<Object> result = NewError(maker, message, object); 776 return result.EscapeFrom(&scope); 777 } 778 779 780 Handle<Object> Factory::NewEvalError(const char* message, 781 Vector< Handle<Object> > args) { 782 return NewError("MakeEvalError", message, args); 783 } 784 785 786 Handle<Object> Factory::NewError(const char* message, 787 Vector< Handle<Object> > args) { 788 return NewError("MakeError", message, args); 789 } 790 791 792 Handle<String> Factory::EmergencyNewError(const char* message, 793 Handle<JSArray> args) { 794 const int kBufferSize = 1000; 795 char buffer[kBufferSize]; 796 size_t space = kBufferSize; 797 char* p = &buffer[0]; 798 799 Vector<char> v(buffer, kBufferSize); 800 OS::StrNCpy(v, message, space); 801 space -= Min(space, strlen(message)); 802 p = &buffer[kBufferSize] - space; 803 804 for (unsigned i = 0; i < ARRAY_SIZE(args); i++) { 805 if (space > 0) { 806 *p++ = ' '; 807 space--; 808 if (space > 0) { 809 MaybeObject* maybe_arg = args->GetElement(i); 810 Handle<String> arg_str(reinterpret_cast<String*>(maybe_arg)); 811 const char* arg = *arg_str->ToCString(); 812 Vector<char> v2(p, static_cast<int>(space)); 813 OS::StrNCpy(v2, arg, space); 814 space -= Min(space, strlen(arg)); 815 p = &buffer[kBufferSize] - space; 816 } 817 } 818 } 819 if (space > 0) { 820 *p = '\0'; 821 } else { 822 buffer[kBufferSize - 1] = '\0'; 823 } 824 Handle<String> error_string = NewStringFromUtf8(CStrVector(buffer), TENURED); 825 return error_string; 826 } 827 828 829 Handle<Object> Factory::NewError(const char* maker, 830 const char* message, 831 Handle<JSArray> args) { 832 Handle<String> make_str = InternalizeUtf8String(maker); 833 Handle<Object> fun_obj( 834 isolate()->js_builtins_object()->GetPropertyNoExceptionThrown(*make_str), 835 isolate()); 836 // If the builtins haven't been properly configured yet this error 837 // constructor may not have been defined. Bail out. 838 if (!fun_obj->IsJSFunction()) { 839 return EmergencyNewError(message, args); 840 } 841 Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj); 842 Handle<Object> message_obj = InternalizeUtf8String(message); 843 Handle<Object> argv[] = { message_obj, args }; 844 845 // Invoke the JavaScript factory method. If an exception is thrown while 846 // running the factory method, use the exception as the result. 847 bool caught_exception; 848 Handle<Object> result = Execution::TryCall(fun, 849 isolate()->js_builtins_object(), 850 ARRAY_SIZE(argv), 851 argv, 852 &caught_exception); 853 return result; 854 } 855 856 857 Handle<Object> Factory::NewError(Handle<String> message) { 858 return NewError("$Error", message); 859 } 860 861 862 Handle<Object> Factory::NewError(const char* constructor, 863 Handle<String> message) { 864 Handle<String> constr = InternalizeUtf8String(constructor); 865 Handle<JSFunction> fun = Handle<JSFunction>( 866 JSFunction::cast(isolate()->js_builtins_object()-> 867 GetPropertyNoExceptionThrown(*constr))); 868 Handle<Object> argv[] = { message }; 869 870 // Invoke the JavaScript factory method. If an exception is thrown while 871 // running the factory method, use the exception as the result. 872 bool caught_exception; 873 Handle<Object> result = Execution::TryCall(fun, 874 isolate()->js_builtins_object(), 875 ARRAY_SIZE(argv), 876 argv, 877 &caught_exception); 878 return result; 879 } 880 881 882 Handle<JSFunction> Factory::NewFunction(Handle<String> name, 883 InstanceType type, 884 int instance_size, 885 Handle<Code> code, 886 bool force_initial_map) { 887 // Allocate the function 888 Handle<JSFunction> function = NewFunction(name, the_hole_value()); 889 890 // Set up the code pointer in both the shared function info and in 891 // the function itself. 892 function->shared()->set_code(*code); 893 function->set_code(*code); 894 895 if (force_initial_map || 896 type != JS_OBJECT_TYPE || 897 instance_size != JSObject::kHeaderSize) { 898 Handle<Map> initial_map = NewMap(type, instance_size); 899 Handle<JSObject> prototype = NewFunctionPrototype(function); 900 initial_map->set_prototype(*prototype); 901 function->set_initial_map(*initial_map); 902 initial_map->set_constructor(*function); 903 } else { 904 ASSERT(!function->has_initial_map()); 905 ASSERT(!function->has_prototype()); 906 } 907 908 return function; 909 } 910 911 912 Handle<JSFunction> Factory::NewFunctionWithPrototype(Handle<String> name, 913 InstanceType type, 914 int instance_size, 915 Handle<JSObject> prototype, 916 Handle<Code> code, 917 bool force_initial_map) { 918 // Allocate the function. 919 Handle<JSFunction> function = NewFunction(name, prototype); 920 921 // Set up the code pointer in both the shared function info and in 922 // the function itself. 923 function->shared()->set_code(*code); 924 function->set_code(*code); 925 926 if (force_initial_map || 927 type != JS_OBJECT_TYPE || 928 instance_size != JSObject::kHeaderSize) { 929 Handle<Map> initial_map = NewMap(type, 930 instance_size, 931 GetInitialFastElementsKind()); 932 function->set_initial_map(*initial_map); 933 initial_map->set_constructor(*function); 934 } 935 936 JSFunction::SetPrototype(function, prototype); 937 return function; 938 } 939 940 941 Handle<JSFunction> Factory::NewFunctionWithoutPrototype(Handle<String> name, 942 Handle<Code> code) { 943 Handle<JSFunction> function = NewFunctionWithoutPrototype(name, 944 CLASSIC_MODE); 945 function->shared()->set_code(*code); 946 function->set_code(*code); 947 ASSERT(!function->has_initial_map()); 948 ASSERT(!function->has_prototype()); 949 return function; 950 } 951 952 953 Handle<ScopeInfo> Factory::NewScopeInfo(int length) { 954 CALL_HEAP_FUNCTION( 955 isolate(), 956 isolate()->heap()->AllocateScopeInfo(length), 957 ScopeInfo); 958 } 959 960 961 Handle<JSObject> Factory::NewExternal(void* value) { 962 CALL_HEAP_FUNCTION(isolate(), 963 isolate()->heap()->AllocateExternal(value), 964 JSObject); 965 } 966 967 968 Handle<Code> Factory::NewCode(const CodeDesc& desc, 969 Code::Flags flags, 970 Handle<Object> self_ref, 971 bool immovable, 972 bool crankshafted) { 973 CALL_HEAP_FUNCTION(isolate(), 974 isolate()->heap()->CreateCode( 975 desc, flags, self_ref, immovable, crankshafted), 976 Code); 977 } 978 979 980 Handle<Code> Factory::CopyCode(Handle<Code> code) { 981 CALL_HEAP_FUNCTION(isolate(), 982 isolate()->heap()->CopyCode(*code), 983 Code); 984 } 985 986 987 Handle<Code> Factory::CopyCode(Handle<Code> code, Vector<byte> reloc_info) { 988 CALL_HEAP_FUNCTION(isolate(), 989 isolate()->heap()->CopyCode(*code, reloc_info), 990 Code); 991 } 992 993 994 Handle<String> Factory::InternalizedStringFromString(Handle<String> value) { 995 CALL_HEAP_FUNCTION(isolate(), 996 isolate()->heap()->InternalizeString(*value), String); 997 } 998 999 1000 Handle<JSObject> Factory::NewJSObject(Handle<JSFunction> constructor, 1001 PretenureFlag pretenure) { 1002 CALL_HEAP_FUNCTION( 1003 isolate(), 1004 isolate()->heap()->AllocateJSObject(*constructor, pretenure), JSObject); 1005 } 1006 1007 1008 Handle<JSModule> Factory::NewJSModule(Handle<Context> context, 1009 Handle<ScopeInfo> scope_info) { 1010 CALL_HEAP_FUNCTION( 1011 isolate(), 1012 isolate()->heap()->AllocateJSModule(*context, *scope_info), JSModule); 1013 } 1014 1015 1016 Handle<GlobalObject> Factory::NewGlobalObject( 1017 Handle<JSFunction> constructor) { 1018 CALL_HEAP_FUNCTION(isolate(), 1019 isolate()->heap()->AllocateGlobalObject(*constructor), 1020 GlobalObject); 1021 } 1022 1023 1024 1025 Handle<JSObject> Factory::NewJSObjectFromMap(Handle<Map> map, 1026 PretenureFlag pretenure, 1027 bool alloc_props) { 1028 CALL_HEAP_FUNCTION( 1029 isolate(), 1030 isolate()->heap()->AllocateJSObjectFromMap(*map, pretenure, alloc_props), 1031 JSObject); 1032 } 1033 1034 1035 Handle<JSArray> Factory::NewJSArray(int capacity, 1036 ElementsKind elements_kind, 1037 PretenureFlag pretenure) { 1038 if (capacity != 0) { 1039 elements_kind = GetHoleyElementsKind(elements_kind); 1040 } 1041 CALL_HEAP_FUNCTION(isolate(), 1042 isolate()->heap()->AllocateJSArrayAndStorage( 1043 elements_kind, 1044 0, 1045 capacity, 1046 INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE, 1047 pretenure), 1048 JSArray); 1049 } 1050 1051 1052 Handle<JSArray> Factory::NewJSArrayWithElements(Handle<FixedArrayBase> elements, 1053 ElementsKind elements_kind, 1054 PretenureFlag pretenure) { 1055 CALL_HEAP_FUNCTION( 1056 isolate(), 1057 isolate()->heap()->AllocateJSArrayWithElements(*elements, 1058 elements_kind, 1059 elements->length(), 1060 pretenure), 1061 JSArray); 1062 } 1063 1064 1065 void Factory::SetElementsCapacityAndLength(Handle<JSArray> array, 1066 int capacity, 1067 int length) { 1068 ElementsAccessor* accessor = array->GetElementsAccessor(); 1069 CALL_HEAP_FUNCTION_VOID( 1070 isolate(), 1071 accessor->SetCapacityAndLength(*array, capacity, length)); 1072 } 1073 1074 1075 void Factory::SetContent(Handle<JSArray> array, 1076 Handle<FixedArrayBase> elements) { 1077 CALL_HEAP_FUNCTION_VOID( 1078 isolate(), 1079 array->SetContent(*elements)); 1080 } 1081 1082 1083 void Factory::EnsureCanContainHeapObjectElements(Handle<JSArray> array) { 1084 CALL_HEAP_FUNCTION_VOID( 1085 isolate(), 1086 array->EnsureCanContainHeapObjectElements()); 1087 } 1088 1089 1090 void Factory::EnsureCanContainElements(Handle<JSArray> array, 1091 Handle<FixedArrayBase> elements, 1092 uint32_t length, 1093 EnsureElementsMode mode) { 1094 CALL_HEAP_FUNCTION_VOID( 1095 isolate(), 1096 array->EnsureCanContainElements(*elements, length, mode)); 1097 } 1098 1099 1100 Handle<JSArrayBuffer> Factory::NewJSArrayBuffer() { 1101 Handle<JSFunction> array_buffer_fun( 1102 isolate()->context()->native_context()->array_buffer_fun()); 1103 CALL_HEAP_FUNCTION( 1104 isolate(), 1105 isolate()->heap()->AllocateJSObject(*array_buffer_fun), 1106 JSArrayBuffer); 1107 } 1108 1109 1110 Handle<JSDataView> Factory::NewJSDataView() { 1111 Handle<JSFunction> data_view_fun( 1112 isolate()->context()->native_context()->data_view_fun()); 1113 CALL_HEAP_FUNCTION( 1114 isolate(), 1115 isolate()->heap()->AllocateJSObject(*data_view_fun), 1116 JSDataView); 1117 } 1118 1119 1120 static JSFunction* GetTypedArrayFun(ExternalArrayType type, 1121 Isolate* isolate) { 1122 Context* native_context = isolate->context()->native_context(); 1123 switch (type) { 1124 case kExternalUnsignedByteArray: 1125 return native_context->uint8_array_fun(); 1126 1127 case kExternalByteArray: 1128 return native_context->int8_array_fun(); 1129 1130 case kExternalUnsignedShortArray: 1131 return native_context->uint16_array_fun(); 1132 1133 case kExternalShortArray: 1134 return native_context->int16_array_fun(); 1135 1136 case kExternalUnsignedIntArray: 1137 return native_context->uint32_array_fun(); 1138 1139 case kExternalIntArray: 1140 return native_context->int32_array_fun(); 1141 1142 case kExternalFloatArray: 1143 return native_context->float_array_fun(); 1144 1145 case kExternalDoubleArray: 1146 return native_context->double_array_fun(); 1147 1148 case kExternalPixelArray: 1149 return native_context->uint8c_array_fun(); 1150 1151 default: 1152 UNREACHABLE(); 1153 return NULL; 1154 } 1155 } 1156 1157 1158 Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type) { 1159 Handle<JSFunction> typed_array_fun_handle(GetTypedArrayFun(type, isolate())); 1160 1161 CALL_HEAP_FUNCTION( 1162 isolate(), 1163 isolate()->heap()->AllocateJSObject(*typed_array_fun_handle), 1164 JSTypedArray); 1165 } 1166 1167 1168 Handle<JSProxy> Factory::NewJSProxy(Handle<Object> handler, 1169 Handle<Object> prototype) { 1170 CALL_HEAP_FUNCTION( 1171 isolate(), 1172 isolate()->heap()->AllocateJSProxy(*handler, *prototype), 1173 JSProxy); 1174 } 1175 1176 1177 void Factory::BecomeJSObject(Handle<JSReceiver> object) { 1178 CALL_HEAP_FUNCTION_VOID( 1179 isolate(), 1180 isolate()->heap()->ReinitializeJSReceiver( 1181 *object, JS_OBJECT_TYPE, JSObject::kHeaderSize)); 1182 } 1183 1184 1185 void Factory::BecomeJSFunction(Handle<JSReceiver> object) { 1186 CALL_HEAP_FUNCTION_VOID( 1187 isolate(), 1188 isolate()->heap()->ReinitializeJSReceiver( 1189 *object, JS_FUNCTION_TYPE, JSFunction::kSize)); 1190 } 1191 1192 1193 void Factory::SetIdentityHash(Handle<JSObject> object, Smi* hash) { 1194 CALL_HEAP_FUNCTION_VOID( 1195 isolate(), 1196 object->SetIdentityHash(hash, ALLOW_CREATION)); 1197 } 1198 1199 1200 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo( 1201 Handle<String> name, 1202 int number_of_literals, 1203 bool is_generator, 1204 Handle<Code> code, 1205 Handle<ScopeInfo> scope_info) { 1206 Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(name); 1207 shared->set_code(*code); 1208 shared->set_scope_info(*scope_info); 1209 int literals_array_size = number_of_literals; 1210 // If the function contains object, regexp or array literals, 1211 // allocate extra space for a literals array prefix containing the 1212 // context. 1213 if (number_of_literals > 0) { 1214 literals_array_size += JSFunction::kLiteralsPrefixSize; 1215 } 1216 shared->set_num_literals(literals_array_size); 1217 if (is_generator) { 1218 shared->set_instance_class_name(isolate()->heap()->Generator_string()); 1219 shared->DisableOptimization(kGenerator); 1220 } 1221 return shared; 1222 } 1223 1224 1225 Handle<JSMessageObject> Factory::NewJSMessageObject( 1226 Handle<String> type, 1227 Handle<JSArray> arguments, 1228 int start_position, 1229 int end_position, 1230 Handle<Object> script, 1231 Handle<Object> stack_trace, 1232 Handle<Object> stack_frames) { 1233 CALL_HEAP_FUNCTION(isolate(), 1234 isolate()->heap()->AllocateJSMessageObject(*type, 1235 *arguments, 1236 start_position, 1237 end_position, 1238 *script, 1239 *stack_trace, 1240 *stack_frames), 1241 JSMessageObject); 1242 } 1243 1244 1245 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(Handle<String> name) { 1246 CALL_HEAP_FUNCTION(isolate(), 1247 isolate()->heap()->AllocateSharedFunctionInfo(*name), 1248 SharedFunctionInfo); 1249 } 1250 1251 1252 Handle<String> Factory::NumberToString(Handle<Object> number) { 1253 CALL_HEAP_FUNCTION(isolate(), 1254 isolate()->heap()->NumberToString(*number), String); 1255 } 1256 1257 1258 Handle<String> Factory::Uint32ToString(uint32_t value) { 1259 CALL_HEAP_FUNCTION(isolate(), 1260 isolate()->heap()->Uint32ToString(value), String); 1261 } 1262 1263 1264 Handle<SeededNumberDictionary> Factory::DictionaryAtNumberPut( 1265 Handle<SeededNumberDictionary> dictionary, 1266 uint32_t key, 1267 Handle<Object> value) { 1268 CALL_HEAP_FUNCTION(isolate(), 1269 dictionary->AtNumberPut(key, *value), 1270 SeededNumberDictionary); 1271 } 1272 1273 1274 Handle<UnseededNumberDictionary> Factory::DictionaryAtNumberPut( 1275 Handle<UnseededNumberDictionary> dictionary, 1276 uint32_t key, 1277 Handle<Object> value) { 1278 CALL_HEAP_FUNCTION(isolate(), 1279 dictionary->AtNumberPut(key, *value), 1280 UnseededNumberDictionary); 1281 } 1282 1283 1284 Handle<JSFunction> Factory::NewFunctionHelper(Handle<String> name, 1285 Handle<Object> prototype) { 1286 Handle<SharedFunctionInfo> function_share = NewSharedFunctionInfo(name); 1287 CALL_HEAP_FUNCTION( 1288 isolate(), 1289 isolate()->heap()->AllocateFunction(*isolate()->function_map(), 1290 *function_share, 1291 *prototype), 1292 JSFunction); 1293 } 1294 1295 1296 Handle<JSFunction> Factory::NewFunction(Handle<String> name, 1297 Handle<Object> prototype) { 1298 Handle<JSFunction> fun = NewFunctionHelper(name, prototype); 1299 fun->set_context(isolate()->context()->native_context()); 1300 return fun; 1301 } 1302 1303 1304 Handle<JSFunction> Factory::NewFunctionWithoutPrototypeHelper( 1305 Handle<String> name, 1306 LanguageMode language_mode) { 1307 Handle<SharedFunctionInfo> function_share = NewSharedFunctionInfo(name); 1308 Handle<Map> map = (language_mode == CLASSIC_MODE) 1309 ? isolate()->function_without_prototype_map() 1310 : isolate()->strict_mode_function_without_prototype_map(); 1311 CALL_HEAP_FUNCTION(isolate(), 1312 isolate()->heap()->AllocateFunction( 1313 *map, 1314 *function_share, 1315 *the_hole_value()), 1316 JSFunction); 1317 } 1318 1319 1320 Handle<JSFunction> Factory::NewFunctionWithoutPrototype( 1321 Handle<String> name, 1322 LanguageMode language_mode) { 1323 Handle<JSFunction> fun = 1324 NewFunctionWithoutPrototypeHelper(name, language_mode); 1325 fun->set_context(isolate()->context()->native_context()); 1326 return fun; 1327 } 1328 1329 1330 Handle<Object> Factory::ToObject(Handle<Object> object) { 1331 CALL_HEAP_FUNCTION(isolate(), object->ToObject(), Object); 1332 } 1333 1334 1335 Handle<Object> Factory::ToObject(Handle<Object> object, 1336 Handle<Context> native_context) { 1337 CALL_HEAP_FUNCTION(isolate(), object->ToObject(*native_context), Object); 1338 } 1339 1340 1341 #ifdef ENABLE_DEBUGGER_SUPPORT 1342 Handle<DebugInfo> Factory::NewDebugInfo(Handle<SharedFunctionInfo> shared) { 1343 // Get the original code of the function. 1344 Handle<Code> code(shared->code()); 1345 1346 // Create a copy of the code before allocating the debug info object to avoid 1347 // allocation while setting up the debug info object. 1348 Handle<Code> original_code(*Factory::CopyCode(code)); 1349 1350 // Allocate initial fixed array for active break points before allocating the 1351 // debug info object to avoid allocation while setting up the debug info 1352 // object. 1353 Handle<FixedArray> break_points( 1354 NewFixedArray(Debug::kEstimatedNofBreakPointsInFunction)); 1355 1356 // Create and set up the debug info object. Debug info contains function, a 1357 // copy of the original code, the executing code and initial fixed array for 1358 // active break points. 1359 Handle<DebugInfo> debug_info = 1360 Handle<DebugInfo>::cast(NewStruct(DEBUG_INFO_TYPE)); 1361 debug_info->set_shared(*shared); 1362 debug_info->set_original_code(*original_code); 1363 debug_info->set_code(*code); 1364 debug_info->set_break_points(*break_points); 1365 1366 // Link debug info to function. 1367 shared->set_debug_info(*debug_info); 1368 1369 return debug_info; 1370 } 1371 #endif 1372 1373 1374 Handle<JSObject> Factory::NewArgumentsObject(Handle<Object> callee, 1375 int length) { 1376 CALL_HEAP_FUNCTION( 1377 isolate(), 1378 isolate()->heap()->AllocateArgumentsObject(*callee, length), JSObject); 1379 } 1380 1381 1382 Handle<JSFunction> Factory::CreateApiFunction( 1383 Handle<FunctionTemplateInfo> obj, ApiInstanceType instance_type) { 1384 Handle<Code> code = isolate()->builtins()->HandleApiCall(); 1385 Handle<Code> construct_stub = isolate()->builtins()->JSConstructStubApi(); 1386 1387 int internal_field_count = 0; 1388 if (!obj->instance_template()->IsUndefined()) { 1389 Handle<ObjectTemplateInfo> instance_template = 1390 Handle<ObjectTemplateInfo>( 1391 ObjectTemplateInfo::cast(obj->instance_template())); 1392 internal_field_count = 1393 Smi::cast(instance_template->internal_field_count())->value(); 1394 } 1395 1396 // TODO(svenpanne) Kill ApiInstanceType and refactor things by generalizing 1397 // JSObject::GetHeaderSize. 1398 int instance_size = kPointerSize * internal_field_count; 1399 InstanceType type; 1400 switch (instance_type) { 1401 case JavaScriptObject: 1402 type = JS_OBJECT_TYPE; 1403 instance_size += JSObject::kHeaderSize; 1404 break; 1405 case InnerGlobalObject: 1406 type = JS_GLOBAL_OBJECT_TYPE; 1407 instance_size += JSGlobalObject::kSize; 1408 break; 1409 case OuterGlobalObject: 1410 type = JS_GLOBAL_PROXY_TYPE; 1411 instance_size += JSGlobalProxy::kSize; 1412 break; 1413 default: 1414 UNREACHABLE(); 1415 type = JS_OBJECT_TYPE; // Keep the compiler happy. 1416 break; 1417 } 1418 1419 Handle<JSFunction> result = 1420 NewFunction(Factory::empty_string(), 1421 type, 1422 instance_size, 1423 code, 1424 true); 1425 1426 // Set length. 1427 result->shared()->set_length(obj->length()); 1428 1429 // Set class name. 1430 Handle<Object> class_name = Handle<Object>(obj->class_name(), isolate()); 1431 if (class_name->IsString()) { 1432 result->shared()->set_instance_class_name(*class_name); 1433 result->shared()->set_name(*class_name); 1434 } 1435 1436 Handle<Map> map = Handle<Map>(result->initial_map()); 1437 1438 // Mark as undetectable if needed. 1439 if (obj->undetectable()) { 1440 map->set_is_undetectable(); 1441 } 1442 1443 // Mark as hidden for the __proto__ accessor if needed. 1444 if (obj->hidden_prototype()) { 1445 map->set_is_hidden_prototype(); 1446 } 1447 1448 // Mark as needs_access_check if needed. 1449 if (obj->needs_access_check()) { 1450 map->set_is_access_check_needed(true); 1451 } 1452 1453 // Set interceptor information in the map. 1454 if (!obj->named_property_handler()->IsUndefined()) { 1455 map->set_has_named_interceptor(); 1456 } 1457 if (!obj->indexed_property_handler()->IsUndefined()) { 1458 map->set_has_indexed_interceptor(); 1459 } 1460 1461 // Set instance call-as-function information in the map. 1462 if (!obj->instance_call_handler()->IsUndefined()) { 1463 map->set_has_instance_call_handler(); 1464 } 1465 1466 result->shared()->set_function_data(*obj); 1467 result->shared()->set_construct_stub(*construct_stub); 1468 result->shared()->DontAdaptArguments(); 1469 1470 // Recursively copy parent templates' accessors, 'data' may be modified. 1471 int max_number_of_additional_properties = 0; 1472 FunctionTemplateInfo* info = *obj; 1473 while (true) { 1474 Object* props = info->property_accessors(); 1475 if (!props->IsUndefined()) { 1476 Handle<Object> props_handle(props, isolate()); 1477 NeanderArray props_array(props_handle); 1478 max_number_of_additional_properties += props_array.length(); 1479 } 1480 Object* parent = info->parent_template(); 1481 if (parent->IsUndefined()) break; 1482 info = FunctionTemplateInfo::cast(parent); 1483 } 1484 1485 Map::EnsureDescriptorSlack(map, max_number_of_additional_properties); 1486 1487 while (true) { 1488 Handle<Object> props = Handle<Object>(obj->property_accessors(), 1489 isolate()); 1490 if (!props->IsUndefined()) { 1491 Map::AppendCallbackDescriptors(map, props); 1492 } 1493 Handle<Object> parent = Handle<Object>(obj->parent_template(), isolate()); 1494 if (parent->IsUndefined()) break; 1495 obj = Handle<FunctionTemplateInfo>::cast(parent); 1496 } 1497 1498 ASSERT(result->shared()->IsApiFunction()); 1499 return result; 1500 } 1501 1502 1503 Handle<MapCache> Factory::NewMapCache(int at_least_space_for) { 1504 CALL_HEAP_FUNCTION(isolate(), 1505 MapCache::Allocate(isolate()->heap(), 1506 at_least_space_for), 1507 MapCache); 1508 } 1509 1510 1511 MUST_USE_RESULT static MaybeObject* UpdateMapCacheWith(Context* context, 1512 FixedArray* keys, 1513 Map* map) { 1514 Object* result; 1515 { MaybeObject* maybe_result = 1516 MapCache::cast(context->map_cache())->Put(keys, map); 1517 if (!maybe_result->ToObject(&result)) return maybe_result; 1518 } 1519 context->set_map_cache(MapCache::cast(result)); 1520 return result; 1521 } 1522 1523 1524 Handle<MapCache> Factory::AddToMapCache(Handle<Context> context, 1525 Handle<FixedArray> keys, 1526 Handle<Map> map) { 1527 CALL_HEAP_FUNCTION(isolate(), 1528 UpdateMapCacheWith(*context, *keys, *map), MapCache); 1529 } 1530 1531 1532 Handle<Map> Factory::ObjectLiteralMapFromCache(Handle<Context> context, 1533 Handle<FixedArray> keys) { 1534 if (context->map_cache()->IsUndefined()) { 1535 // Allocate the new map cache for the native context. 1536 Handle<MapCache> new_cache = NewMapCache(24); 1537 context->set_map_cache(*new_cache); 1538 } 1539 // Check to see whether there is a matching element in the cache. 1540 Handle<MapCache> cache = 1541 Handle<MapCache>(MapCache::cast(context->map_cache())); 1542 Handle<Object> result = Handle<Object>(cache->Lookup(*keys), isolate()); 1543 if (result->IsMap()) return Handle<Map>::cast(result); 1544 // Create a new map and add it to the cache. 1545 Handle<Map> map = 1546 CopyMap(Handle<Map>(context->object_function()->initial_map()), 1547 keys->length()); 1548 AddToMapCache(context, keys, map); 1549 return Handle<Map>(map); 1550 } 1551 1552 1553 void Factory::SetRegExpAtomData(Handle<JSRegExp> regexp, 1554 JSRegExp::Type type, 1555 Handle<String> source, 1556 JSRegExp::Flags flags, 1557 Handle<Object> data) { 1558 Handle<FixedArray> store = NewFixedArray(JSRegExp::kAtomDataSize); 1559 1560 store->set(JSRegExp::kTagIndex, Smi::FromInt(type)); 1561 store->set(JSRegExp::kSourceIndex, *source); 1562 store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value())); 1563 store->set(JSRegExp::kAtomPatternIndex, *data); 1564 regexp->set_data(*store); 1565 } 1566 1567 void Factory::SetRegExpIrregexpData(Handle<JSRegExp> regexp, 1568 JSRegExp::Type type, 1569 Handle<String> source, 1570 JSRegExp::Flags flags, 1571 int capture_count) { 1572 Handle<FixedArray> store = NewFixedArray(JSRegExp::kIrregexpDataSize); 1573 Smi* uninitialized = Smi::FromInt(JSRegExp::kUninitializedValue); 1574 store->set(JSRegExp::kTagIndex, Smi::FromInt(type)); 1575 store->set(JSRegExp::kSourceIndex, *source); 1576 store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value())); 1577 store->set(JSRegExp::kIrregexpASCIICodeIndex, uninitialized); 1578 store->set(JSRegExp::kIrregexpUC16CodeIndex, uninitialized); 1579 store->set(JSRegExp::kIrregexpASCIICodeSavedIndex, uninitialized); 1580 store->set(JSRegExp::kIrregexpUC16CodeSavedIndex, uninitialized); 1581 store->set(JSRegExp::kIrregexpMaxRegisterCountIndex, Smi::FromInt(0)); 1582 store->set(JSRegExp::kIrregexpCaptureCountIndex, 1583 Smi::FromInt(capture_count)); 1584 regexp->set_data(*store); 1585 } 1586 1587 1588 1589 void Factory::ConfigureInstance(Handle<FunctionTemplateInfo> desc, 1590 Handle<JSObject> instance, 1591 bool* pending_exception) { 1592 // Configure the instance by adding the properties specified by the 1593 // instance template. 1594 Handle<Object> instance_template(desc->instance_template(), isolate()); 1595 if (!instance_template->IsUndefined()) { 1596 Execution::ConfigureInstance(instance, 1597 instance_template, 1598 pending_exception); 1599 } else { 1600 *pending_exception = false; 1601 } 1602 } 1603 1604 1605 Handle<Object> Factory::GlobalConstantFor(Handle<String> name) { 1606 Heap* h = isolate()->heap(); 1607 if (name->Equals(h->undefined_string())) return undefined_value(); 1608 if (name->Equals(h->nan_string())) return nan_value(); 1609 if (name->Equals(h->infinity_string())) return infinity_value(); 1610 return Handle<Object>::null(); 1611 } 1612 1613 1614 Handle<Object> Factory::ToBoolean(bool value) { 1615 return value ? true_value() : false_value(); 1616 } 1617 1618 1619 } } // namespace v8::internal 1620