src/factory.cc

   1 // Copyright 2014 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "src/factory.h"
   6
   7 #include "src/allocation-site-scopes.h"
   8 #include "src/base/bits.h"
   9 #include "src/bootstrapper.h"
  10 #include "src/conversions.h"
  11 #include "src/macro-assembler.h"
  12
  13 namespace v8 {
  14 namespace internal {
  15
  16
  17 template<typename T>
  18 Handle<T> Factory::New(Handle<Map> map, AllocationSpace space) {
  19   CALL_HEAP_FUNCTION(
  20       isolate(),
  21       isolate()->heap()->Allocate(*map, space),
  22       T);
  23 }
  24
  25
  26 template<typename T>
  27 Handle<T> Factory::New(Handle<Map> map,
  28                        AllocationSpace space,
  29                        Handle<AllocationSite> allocation_site) {
  30   CALL_HEAP_FUNCTION(
  31       isolate(),
  32       isolate()->heap()->Allocate(*map, space, *allocation_site),
  33       T);
  34 }
  35
  36
  37 Handle<HeapObject> Factory::NewFillerObject(int size,
  38                                             bool double_align,
  39                                             AllocationSpace space) {
  40   CALL_HEAP_FUNCTION(
  41       isolate(),
  42       isolate()->heap()->AllocateFillerObject(size, double_align, space),
  43       HeapObject);
  44 }
  45
  46
  47 Handle<Box> Factory::NewBox(Handle<Object> value) {
  48   Handle<Box> result = Handle<Box>::cast(NewStruct(BOX_TYPE));
  49   result->set_value(*value);
  50   return result;
  51 }
  52
  53
  54 Handle<PrototypeInfo> Factory::NewPrototypeInfo() {
  55   Handle<PrototypeInfo> result =
  56       Handle<PrototypeInfo>::cast(NewStruct(PROTOTYPE_INFO_TYPE));
  57   result->set_prototype_users(WeakFixedArray::Empty());
  58   result->set_registry_slot(PrototypeInfo::UNREGISTERED);
  59   result->set_validity_cell(Smi::FromInt(0));
  60   result->set_constructor_name(Smi::FromInt(0));
  61   return result;
  62 }
  63
  64
  65 Handle<Oddball> Factory::NewOddball(Handle<Map> map, const char* to_string,
  66                                     Handle<Object> to_number,
  67                                     const char* type_of, byte kind) {
  68   Handle<Oddball> oddball = New<Oddball>(map, OLD_SPACE);
  69   Oddball::Initialize(isolate(), oddball, to_string, to_number, type_of, kind);
  70   return oddball;
  71 }
  72
  73
  74 Handle<FixedArray> Factory::NewFixedArray(int size, PretenureFlag pretenure) {
  75   DCHECK(0 <= size);
  76   CALL_HEAP_FUNCTION(
  77       isolate(),
  78       isolate()->heap()->AllocateFixedArray(size, pretenure),
  79       FixedArray);
  80 }
  81
  82
  83 Handle<FixedArray> Factory::NewFixedArrayWithHoles(int size,
  84                                                    PretenureFlag pretenure) {
  85   DCHECK(0 <= size);
  86   CALL_HEAP_FUNCTION(
  87       isolate(),
  88       isolate()->heap()->AllocateFixedArrayWithFiller(size,
  89                                                       pretenure,
  90                                                       *the_hole_value()),
  91       FixedArray);
  92 }
  93
  94
  95 Handle<FixedArray> Factory::NewUninitializedFixedArray(int size) {
  96   CALL_HEAP_FUNCTION(
  97       isolate(),
  98       isolate()->heap()->AllocateUninitializedFixedArray(size),
  99       FixedArray);
 100 }
 101
 102
 103 Handle<FixedArrayBase> Factory::NewFixedDoubleArray(int size,
 104                                                     PretenureFlag pretenure) {
 105   DCHECK(0 <= size);
 106   CALL_HEAP_FUNCTION(
 107       isolate(),
 108       isolate()->heap()->AllocateUninitializedFixedDoubleArray(size, pretenure),
 109       FixedArrayBase);
 110 }
 111
 112
 113 Handle<FixedArrayBase> Factory::NewFixedDoubleArrayWithHoles(
 114     int size,
 115     PretenureFlag pretenure) {
 116   DCHECK(0 <= size);
 117   Handle<FixedArrayBase> array = NewFixedDoubleArray(size, pretenure);
 118   if (size > 0) {
 119     Handle<FixedDoubleArray> double_array =
 120         Handle<FixedDoubleArray>::cast(array);
 121     for (int i = 0; i < size; ++i) {
 122       double_array->set_the_hole(i);
 123     }
 124   }
 125   return array;
 126 }
 127
 128
 129 Handle<OrderedHashSet> Factory::NewOrderedHashSet() {
 130   return OrderedHashSet::Allocate(isolate(), OrderedHashSet::kMinCapacity);
 131 }
 132
 133
 134 Handle<OrderedHashMap> Factory::NewOrderedHashMap() {
 135   return OrderedHashMap::Allocate(isolate(), OrderedHashMap::kMinCapacity);
 136 }
 137
 138
 139 Handle<AccessorPair> Factory::NewAccessorPair() {
 140   Handle<AccessorPair> accessors =
 141       Handle<AccessorPair>::cast(NewStruct(ACCESSOR_PAIR_TYPE));
 142   accessors->set_getter(*the_hole_value(), SKIP_WRITE_BARRIER);
 143   accessors->set_setter(*the_hole_value(), SKIP_WRITE_BARRIER);
 144   return accessors;
 145 }
 146
 147
 148 Handle<TypeFeedbackInfo> Factory::NewTypeFeedbackInfo() {
 149   Handle<TypeFeedbackInfo> info =
 150       Handle<TypeFeedbackInfo>::cast(NewStruct(TYPE_FEEDBACK_INFO_TYPE));
 151   info->initialize_storage();
 152   return info;
 153 }
 154
 155
 156 // Internalized strings are created in the old generation (data space).
 157 Handle<String> Factory::InternalizeUtf8String(Vector<const char> string) {
 158   Utf8StringKey key(string, isolate()->heap()->HashSeed());
 159   return InternalizeStringWithKey(&key);
 160 }
 161
 162
 163 // Internalized strings are created in the old generation (data space).
 164 Handle<String> Factory::InternalizeString(Handle<String> string) {
 165   if (string->IsInternalizedString()) return string;
 166   return StringTable::LookupString(isolate(), string);
 167 }
 168
 169
 170 Handle<String> Factory::InternalizeOneByteString(Vector<const uint8_t> string) {
 171   OneByteStringKey key(string, isolate()->heap()->HashSeed());
 172   return InternalizeStringWithKey(&key);
 173 }
 174
 175
 176 Handle<String> Factory::InternalizeOneByteString(
 177     Handle<SeqOneByteString> string, int from, int length) {
 178   SeqOneByteSubStringKey key(string, from, length);
 179   return InternalizeStringWithKey(&key);
 180 }
 181
 182
 183 Handle<String> Factory::InternalizeTwoByteString(Vector<const uc16> string) {
 184   TwoByteStringKey key(string, isolate()->heap()->HashSeed());
 185   return InternalizeStringWithKey(&key);
 186 }
 187
 188
 189 template<class StringTableKey>
 190 Handle<String> Factory::InternalizeStringWithKey(StringTableKey* key) {
 191   return StringTable::LookupKey(isolate(), key);
 192 }
 193
 194
 195 MaybeHandle<String> Factory::NewStringFromOneByte(Vector<const uint8_t> string,
 196                                                   PretenureFlag pretenure) {
 197   int length = string.length();
 198   if (length == 1) return LookupSingleCharacterStringFromCode(string[0]);
 199   Handle<SeqOneByteString> result;
 200   ASSIGN_RETURN_ON_EXCEPTION(
 201       isolate(),
 202       result,
 203       NewRawOneByteString(string.length(), pretenure),
 204       String);
 205
 206   DisallowHeapAllocation no_gc;
 207   // Copy the characters into the new object.
 208   CopyChars(SeqOneByteString::cast(*result)->GetChars(),
 209             string.start(),
 210             length);
 211   return result;
 212 }
 213
 214 MaybeHandle<String> Factory::NewStringFromUtf8(Vector<const char> string,
 215                                                PretenureFlag pretenure) {
 216   // Check for ASCII first since this is the common case.
 217   const char* start = string.start();
 218   int length = string.length();
 219   int non_ascii_start = String::NonAsciiStart(start, length);
 220   if (non_ascii_start >= length) {
 221     // If the string is ASCII, we do not need to convert the characters
 222     // since UTF8 is backwards compatible with ASCII.
 223     return NewStringFromOneByte(Vector<const uint8_t>::cast(string), pretenure);
 224   }
 225
 226   // Non-ASCII and we need to decode.
 227   Access<UnicodeCache::Utf8Decoder>
 228       decoder(isolate()->unicode_cache()->utf8_decoder());
 229   decoder->Reset(string.start() + non_ascii_start,
 230                  length - non_ascii_start);
 231   int utf16_length = static_cast<int>(decoder->Utf16Length());
 232   DCHECK(utf16_length > 0);
 233   // Allocate string.
 234   Handle<SeqTwoByteString> result;
 235   ASSIGN_RETURN_ON_EXCEPTION(
 236       isolate(), result,
 237       NewRawTwoByteString(non_ascii_start + utf16_length, pretenure),
 238       String);
 239   // Copy ASCII portion.
 240   uint16_t* data = result->GetChars();
 241   const char* ascii_data = string.start();
 242   for (int i = 0; i < non_ascii_start; i++) {
 243     *data++ = *ascii_data++;
 244   }
 245   // Now write the remainder.
 246   decoder->WriteUtf16(data, utf16_length);
 247   return result;
 248 }
 249
 250
 251 MaybeHandle<String> Factory::NewStringFromTwoByte(Vector<const uc16> string,
 252                                                   PretenureFlag pretenure) {
 253   int length = string.length();
 254   const uc16* start = string.start();
 255   if (String::IsOneByte(start, length)) {
 256     if (length == 1) return LookupSingleCharacterStringFromCode(string[0]);
 257     Handle<SeqOneByteString> result;
 258     ASSIGN_RETURN_ON_EXCEPTION(
 259         isolate(),
 260         result,
 261         NewRawOneByteString(length, pretenure),
 262         String);
 263     CopyChars(result->GetChars(), start, length);
 264     return result;
 265   } else {
 266     Handle<SeqTwoByteString> result;
 267     ASSIGN_RETURN_ON_EXCEPTION(
 268         isolate(),
 269         result,
 270         NewRawTwoByteString(length, pretenure),
 271         String);
 272     CopyChars(result->GetChars(), start, length);
 273     return result;
 274   }
 275 }
 276
 277
 278 Handle<String> Factory::NewInternalizedStringFromUtf8(Vector<const char> str,
 279                                                       int chars,
 280                                                       uint32_t hash_field) {
 281   CALL_HEAP_FUNCTION(
 282       isolate(),
 283       isolate()->heap()->AllocateInternalizedStringFromUtf8(
 284           str, chars, hash_field),
 285       String);
 286 }
 287
 288
 289 MUST_USE_RESULT Handle<String> Factory::NewOneByteInternalizedString(
 290       Vector<const uint8_t> str,
 291       uint32_t hash_field) {
 292   CALL_HEAP_FUNCTION(
 293       isolate(),
 294       isolate()->heap()->AllocateOneByteInternalizedString(str, hash_field),
 295       String);
 296 }
 297
 298
 299 MUST_USE_RESULT Handle<String> Factory::NewOneByteInternalizedSubString(
 300     Handle<SeqOneByteString> string, int offset, int length,
 301     uint32_t hash_field) {
 302   CALL_HEAP_FUNCTION(
 303       isolate(), isolate()->heap()->AllocateOneByteInternalizedString(
 304                      Vector<const uint8_t>(string->GetChars() + offset, length),
 305                      hash_field),
 306       String);
 307 }
 308
 309
 310 MUST_USE_RESULT Handle<String> Factory::NewTwoByteInternalizedString(
 311       Vector<const uc16> str,
 312       uint32_t hash_field) {
 313   CALL_HEAP_FUNCTION(
 314       isolate(),
 315       isolate()->heap()->AllocateTwoByteInternalizedString(str, hash_field),
 316       String);
 317 }
 318
 319
 320 Handle<String> Factory::NewInternalizedStringImpl(
 321     Handle<String> string, int chars, uint32_t hash_field) {
 322   CALL_HEAP_FUNCTION(
 323       isolate(),
 324       isolate()->heap()->AllocateInternalizedStringImpl(
 325           *string, chars, hash_field),
 326       String);
 327 }
 328
 329
 330 MaybeHandle<Map> Factory::InternalizedStringMapForString(
 331     Handle<String> string) {
 332   // If the string is in new space it cannot be used as internalized.
 333   if (isolate()->heap()->InNewSpace(*string)) return MaybeHandle<Map>();
 334
 335   // Find the corresponding internalized string map for strings.
 336   switch (string->map()->instance_type()) {
 337     case STRING_TYPE: return internalized_string_map();
 338     case ONE_BYTE_STRING_TYPE:
 339       return one_byte_internalized_string_map();
 340     case EXTERNAL_STRING_TYPE: return external_internalized_string_map();
 341     case EXTERNAL_ONE_BYTE_STRING_TYPE:
 342       return external_one_byte_internalized_string_map();
 343     case EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE:
 344       return external_internalized_string_with_one_byte_data_map();
 345     case SHORT_EXTERNAL_STRING_TYPE:
 346       return short_external_internalized_string_map();
 347     case SHORT_EXTERNAL_ONE_BYTE_STRING_TYPE:
 348       return short_external_one_byte_internalized_string_map();
 349     case SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE:
 350       return short_external_internalized_string_with_one_byte_data_map();
 351     default: return MaybeHandle<Map>();  // No match found.
 352   }
 353 }
 354
 355
 356 MaybeHandle<SeqOneByteString> Factory::NewRawOneByteString(
 357     int length, PretenureFlag pretenure) {
 358   if (length > String::kMaxLength || length < 0) {
 359     THROW_NEW_ERROR(isolate(), NewInvalidStringLengthError(), SeqOneByteString);
 360   }
 361   CALL_HEAP_FUNCTION(
 362       isolate(),
 363       isolate()->heap()->AllocateRawOneByteString(length, pretenure),
 364       SeqOneByteString);
 365 }
 366
 367
 368 MaybeHandle<SeqTwoByteString> Factory::NewRawTwoByteString(
 369     int length, PretenureFlag pretenure) {
 370   if (length > String::kMaxLength || length < 0) {
 371     THROW_NEW_ERROR(isolate(), NewInvalidStringLengthError(), SeqTwoByteString);
 372   }
 373   CALL_HEAP_FUNCTION(
 374       isolate(),
 375       isolate()->heap()->AllocateRawTwoByteString(length, pretenure),
 376       SeqTwoByteString);
 377 }
 378
 379
 380 Handle<String> Factory::LookupSingleCharacterStringFromCode(uint32_t code) {
 381   if (code <= String::kMaxOneByteCharCodeU) {
 382     {
 383       DisallowHeapAllocation no_allocation;
 384       Object* value = single_character_string_cache()->get(code);
 385       if (value != *undefined_value()) {
 386         return handle(String::cast(value), isolate());
 387       }
 388     }
 389     uint8_t buffer[1];
 390     buffer[0] = static_cast<uint8_t>(code);
 391     Handle<String> result =
 392         InternalizeOneByteString(Vector<const uint8_t>(buffer, 1));
 393     single_character_string_cache()->set(code, *result);
 394     return result;
 395   }
 396   DCHECK(code <= String::kMaxUtf16CodeUnitU);
 397
 398   Handle<SeqTwoByteString> result = NewRawTwoByteString(1).ToHandleChecked();
 399   result->SeqTwoByteStringSet(0, static_cast<uint16_t>(code));
 400   return result;
 401 }
 402
 403
 404 // Returns true for a character in a range.  Both limits are inclusive.
 405 static inline bool Between(uint32_t character, uint32_t from, uint32_t to) {
 406   // This makes uses of the the unsigned wraparound.
 407   return character - from <= to - from;
 408 }
 409
 410
 411 static inline Handle<String> MakeOrFindTwoCharacterString(Isolate* isolate,
 412                                                           uint16_t c1,
 413                                                           uint16_t c2) {
 414   // Numeric strings have a different hash algorithm not known by
 415   // LookupTwoCharsStringIfExists, so we skip this step for such strings.
 416   if (!Between(c1, '0', '9') || !Between(c2, '0', '9')) {
 417     Handle<String> result;
 418     if (StringTable::LookupTwoCharsStringIfExists(isolate, c1, c2).
 419         ToHandle(&result)) {
 420       return result;
 421     }
 422   }
 423
 424   // Now we know the length is 2, we might as well make use of that fact
 425   // when building the new string.
 426   if (static_cast<unsigned>(c1 | c2) <= String::kMaxOneByteCharCodeU) {
 427     // We can do this.
 428     DCHECK(base::bits::IsPowerOfTwo32(String::kMaxOneByteCharCodeU +
 429                                       1));  // because of this.
 430     Handle<SeqOneByteString> str =
 431         isolate->factory()->NewRawOneByteString(2).ToHandleChecked();
 432     uint8_t* dest = str->GetChars();
 433     dest[0] = static_cast<uint8_t>(c1);
 434     dest[1] = static_cast<uint8_t>(c2);
 435     return str;
 436   } else {
 437     Handle<SeqTwoByteString> str =
 438         isolate->factory()->NewRawTwoByteString(2).ToHandleChecked();
 439     uc16* dest = str->GetChars();
 440     dest[0] = c1;
 441     dest[1] = c2;
 442     return str;
 443   }
 444 }
 445
 446
 447 template<typename SinkChar, typename StringType>
 448 Handle<String> ConcatStringContent(Handle<StringType> result,
 449                                    Handle<String> first,
 450                                    Handle<String> second) {
 451   DisallowHeapAllocation pointer_stays_valid;
 452   SinkChar* sink = result->GetChars();
 453   String::WriteToFlat(*first, sink, 0, first->length());
 454   String::WriteToFlat(*second, sink + first->length(), 0, second->length());
 455   return result;
 456 }
 457
 458
 459 MaybeHandle<String> Factory::NewConsString(Handle<String> left,
 460                                            Handle<String> right) {
 461   int left_length = left->length();
 462   if (left_length == 0) return right;
 463   int right_length = right->length();
 464   if (right_length == 0) return left;
 465
 466   int length = left_length + right_length;
 467
 468   if (length == 2) {
 469     uint16_t c1 = left->Get(0);
 470     uint16_t c2 = right->Get(0);
 471     return MakeOrFindTwoCharacterString(isolate(), c1, c2);
 472   }
 473
 474   // Make sure that an out of memory exception is thrown if the length
 475   // of the new cons string is too large.
 476   if (length > String::kMaxLength || length < 0) {
 477     THROW_NEW_ERROR(isolate(), NewInvalidStringLengthError(), String);
 478   }
 479
 480   bool left_is_one_byte = left->IsOneByteRepresentation();
 481   bool right_is_one_byte = right->IsOneByteRepresentation();
 482   bool is_one_byte = left_is_one_byte && right_is_one_byte;
 483   bool is_one_byte_data_in_two_byte_string = false;
 484   if (!is_one_byte) {
 485     // At least one of the strings uses two-byte representation so we
 486     // can't use the fast case code for short one-byte strings below, but
 487     // we can try to save memory if all chars actually fit in one-byte.
 488     is_one_byte_data_in_two_byte_string =
 489         left->HasOnlyOneByteChars() && right->HasOnlyOneByteChars();
 490     if (is_one_byte_data_in_two_byte_string) {
 491       isolate()->counters()->string_add_runtime_ext_to_one_byte()->Increment();
 492     }
 493   }
 494
 495   // If the resulting string is small make a flat string.
 496   if (length < ConsString::kMinLength) {
 497     // Note that neither of the two inputs can be a slice because:
 498     STATIC_ASSERT(ConsString::kMinLength <= SlicedString::kMinLength);
 499     DCHECK(left->IsFlat());
 500     DCHECK(right->IsFlat());
 501
 502     STATIC_ASSERT(ConsString::kMinLength <= String::kMaxLength);
 503     if (is_one_byte) {
 504       Handle<SeqOneByteString> result =
 505           NewRawOneByteString(length).ToHandleChecked();
 506       DisallowHeapAllocation no_gc;
 507       uint8_t* dest = result->GetChars();
 508       // Copy left part.
 509       const uint8_t* src =
 510           left->IsExternalString()
 511               ? Handle<ExternalOneByteString>::cast(left)->GetChars()
 512               : Handle<SeqOneByteString>::cast(left)->GetChars();
 513       for (int i = 0; i < left_length; i++) *dest++ = src[i];
 514       // Copy right part.
 515       src = right->IsExternalString()
 516                 ? Handle<ExternalOneByteString>::cast(right)->GetChars()
 517                 : Handle<SeqOneByteString>::cast(right)->GetChars();
 518       for (int i = 0; i < right_length; i++) *dest++ = src[i];
 519       return result;
 520     }
 521
 522     return (is_one_byte_data_in_two_byte_string)
 523         ? ConcatStringContent<uint8_t>(
 524             NewRawOneByteString(length).ToHandleChecked(), left, right)
 525         : ConcatStringContent<uc16>(
 526             NewRawTwoByteString(length).ToHandleChecked(), left, right);
 527   }
 528
 529   return (is_one_byte || is_one_byte_data_in_two_byte_string)
 530              ? NewOneByteConsString(length, left, right)
 531              : NewTwoByteConsString(length, left, right);
 532 }
 533
 534
 535 MaybeHandle<String> Factory::NewOneByteConsString(int length,
 536                                                   Handle<String> left,
 537                                                   Handle<String> right) {
 538   return NewRawConsString(cons_one_byte_string_map(), length, left, right);
 539 }
 540
 541
 542 MaybeHandle<String> Factory::NewTwoByteConsString(int length,
 543                                                   Handle<String> left,
 544                                                   Handle<String> right) {
 545   return NewRawConsString(cons_string_map(), length, left, right);
 546 }
 547
 548
 549 MaybeHandle<String> Factory::NewRawConsString(Handle<Map> map, int length,
 550                                               Handle<String> left,
 551                                               Handle<String> right) {
 552   Handle<ConsString> result = New<ConsString>(map, NEW_SPACE);
 553
 554   DisallowHeapAllocation no_gc;
 555   WriteBarrierMode mode = result->GetWriteBarrierMode(no_gc);
 556
 557   result->set_hash_field(String::kEmptyHashField);
 558   result->set_length(length);
 559   result->set_first(*left, mode);
 560   result->set_second(*right, mode);
 561   return result;
 562 }
 563
 564
 565 Handle<String> Factory::NewProperSubString(Handle<String> str,
 566                                            int begin,
 567                                            int end) {
 568 #if VERIFY_HEAP
 569   if (FLAG_verify_heap) str->StringVerify();
 570 #endif
 571   DCHECK(begin > 0 || end < str->length());
 572
 573   str = String::Flatten(str);
 574
 575   int length = end - begin;
 576   if (length <= 0) return empty_string();
 577   if (length == 1) {
 578     return LookupSingleCharacterStringFromCode(str->Get(begin));
 579   }
 580   if (length == 2) {
 581     // Optimization for 2-byte strings often used as keys in a decompression
 582     // dictionary.  Check whether we already have the string in the string
 583     // table to prevent creation of many unnecessary strings.
 584     uint16_t c1 = str->Get(begin);
 585     uint16_t c2 = str->Get(begin + 1);
 586     return MakeOrFindTwoCharacterString(isolate(), c1, c2);
 587   }
 588
 589   if (!FLAG_string_slices || length < SlicedString::kMinLength) {
 590     if (str->IsOneByteRepresentation()) {
 591       Handle<SeqOneByteString> result =
 592           NewRawOneByteString(length).ToHandleChecked();
 593       uint8_t* dest = result->GetChars();
 594       DisallowHeapAllocation no_gc;
 595       String::WriteToFlat(*str, dest, begin, end);
 596       return result;
 597     } else {
 598       Handle<SeqTwoByteString> result =
 599           NewRawTwoByteString(length).ToHandleChecked();
 600       uc16* dest = result->GetChars();
 601       DisallowHeapAllocation no_gc;
 602       String::WriteToFlat(*str, dest, begin, end);
 603       return result;
 604     }
 605   }
 606
 607   int offset = begin;
 608
 609   if (str->IsSlicedString()) {
 610     Handle<SlicedString> slice = Handle<SlicedString>::cast(str);
 611     str = Handle<String>(slice->parent(), isolate());
 612     offset += slice->offset();
 613   }
 614
 615   DCHECK(str->IsSeqString() || str->IsExternalString());
 616   Handle<Map> map = str->IsOneByteRepresentation()
 617                         ? sliced_one_byte_string_map()
 618                         : sliced_string_map();
 619   Handle<SlicedString> slice = New<SlicedString>(map, NEW_SPACE);
 620
 621   slice->set_hash_field(String::kEmptyHashField);
 622   slice->set_length(length);
 623   slice->set_parent(*str);
 624   slice->set_offset(offset);
 625   return slice;
 626 }
 627
 628
 629 MaybeHandle<String> Factory::NewExternalStringFromOneByte(
 630     const ExternalOneByteString::Resource* resource) {
 631   size_t length = resource->length();
 632   if (length > static_cast<size_t>(String::kMaxLength)) {
 633     THROW_NEW_ERROR(isolate(), NewInvalidStringLengthError(), String);
 634   }
 635
 636   Handle<Map> map = external_one_byte_string_map();
 637   Handle<ExternalOneByteString> external_string =
 638       New<ExternalOneByteString>(map, NEW_SPACE);
 639   external_string->set_length(static_cast<int>(length));
 640   external_string->set_hash_field(String::kEmptyHashField);
 641   external_string->set_resource(resource);
 642
 643   return external_string;
 644 }
 645
 646
 647 MaybeHandle<String> Factory::NewExternalStringFromTwoByte(
 648     const ExternalTwoByteString::Resource* resource) {
 649   size_t length = resource->length();
 650   if (length > static_cast<size_t>(String::kMaxLength)) {
 651     THROW_NEW_ERROR(isolate(), NewInvalidStringLengthError(), String);
 652   }
 653
 654   // For small strings we check whether the resource contains only
 655   // one byte characters.  If yes, we use a different string map.
 656   static const size_t kOneByteCheckLengthLimit = 32;
 657   bool is_one_byte = length <= kOneByteCheckLengthLimit &&
 658       String::IsOneByte(resource->data(), static_cast<int>(length));
 659   Handle<Map> map = is_one_byte ?
 660       external_string_with_one_byte_data_map() : external_string_map();
 661   Handle<ExternalTwoByteString> external_string =
 662       New<ExternalTwoByteString>(map, NEW_SPACE);
 663   external_string->set_length(static_cast<int>(length));
 664   external_string->set_hash_field(String::kEmptyHashField);
 665   external_string->set_resource(resource);
 666
 667   return external_string;
 668 }
 669
 670
 671 Handle<Symbol> Factory::NewSymbol() {
 672   CALL_HEAP_FUNCTION(
 673       isolate(),
 674       isolate()->heap()->AllocateSymbol(),
 675       Symbol);
 676 }
 677
 678
 679 Handle<Symbol> Factory::NewPrivateSymbol(Handle<Object> name) {
 680   Handle<Symbol> symbol = NewSymbol();
 681   symbol->set_is_private(true);
 682   if (name->IsString()) {
 683     symbol->set_name(*name);
 684   } else {
 685     DCHECK(name->IsUndefined());
 686   }
 687   return symbol;
 688 }
 689
 690
 691 Handle<Context> Factory::NewNativeContext() {
 692   Handle<FixedArray> array =
 693       NewFixedArray(Context::NATIVE_CONTEXT_SLOTS, TENURED);
 694   array->set_map_no_write_barrier(*native_context_map());
 695   Handle<Context> context = Handle<Context>::cast(array);
 696   context->set_js_array_maps(*undefined_value());
 697   DCHECK(context->IsNativeContext());
 698   return context;
 699 }
 700
 701
 702 Handle<Context> Factory::NewScriptContext(Handle<JSFunction> function,
 703                                           Handle<ScopeInfo> scope_info) {
 704   Handle<FixedArray> array =
 705       NewFixedArray(scope_info->ContextLength(), TENURED);
 706   array->set_map_no_write_barrier(*script_context_map());
 707   Handle<Context> context = Handle<Context>::cast(array);
 708   context->set_closure(*function);
 709   context->set_previous(function->context());
 710   context->set_extension(*scope_info);
 711   context->set_global_object(function->context()->global_object());
 712   DCHECK(context->IsScriptContext());
 713   return context;
 714 }
 715
 716
 717 Handle<ScriptContextTable> Factory::NewScriptContextTable() {
 718   Handle<FixedArray> array = NewFixedArray(1);
 719   array->set_map_no_write_barrier(*script_context_table_map());
 720   Handle<ScriptContextTable> context_table =
 721       Handle<ScriptContextTable>::cast(array);
 722   context_table->set_used(0);
 723   return context_table;
 724 }
 725
 726
 727 Handle<Context> Factory::NewModuleContext(Handle<ScopeInfo> scope_info) {
 728   Handle<FixedArray> array =
 729       NewFixedArray(scope_info->ContextLength(), TENURED);
 730   array->set_map_no_write_barrier(*module_context_map());
 731   // Instance link will be set later.
 732   Handle<Context> context = Handle<Context>::cast(array);
 733   context->set_extension(Smi::FromInt(0));
 734   return context;
 735 }
 736
 737
 738 Handle<Context> Factory::NewFunctionContext(int length,
 739                                             Handle<JSFunction> function) {
 740   DCHECK(length >= Context::MIN_CONTEXT_SLOTS);
 741   Handle<FixedArray> array = NewFixedArray(length);
 742   array->set_map_no_write_barrier(*function_context_map());
 743   Handle<Context> context = Handle<Context>::cast(array);
 744   context->set_closure(*function);
 745   context->set_previous(function->context());
 746   context->set_extension(Smi::FromInt(0));
 747   context->set_global_object(function->context()->global_object());
 748   return context;
 749 }
 750
 751
 752 Handle<Context> Factory::NewCatchContext(Handle<JSFunction> function,
 753                                          Handle<Context> previous,
 754                                          Handle<String> name,
 755                                          Handle<Object> thrown_object) {
 756   STATIC_ASSERT(Context::MIN_CONTEXT_SLOTS == Context::THROWN_OBJECT_INDEX);
 757   Handle<FixedArray> array = NewFixedArray(Context::MIN_CONTEXT_SLOTS + 1);
 758   array->set_map_no_write_barrier(*catch_context_map());
 759   Handle<Context> context = Handle<Context>::cast(array);
 760   context->set_closure(*function);
 761   context->set_previous(*previous);
 762   context->set_extension(*name);
 763   context->set_global_object(previous->global_object());
 764   context->set(Context::THROWN_OBJECT_INDEX, *thrown_object);
 765   return context;
 766 }
 767
 768
 769 Handle<Context> Factory::NewWithContext(Handle<JSFunction> function,
 770                                         Handle<Context> previous,
 771                                         Handle<JSReceiver> extension) {
 772   Handle<FixedArray> array = NewFixedArray(Context::MIN_CONTEXT_SLOTS);
 773   array->set_map_no_write_barrier(*with_context_map());
 774   Handle<Context> context = Handle<Context>::cast(array);
 775   context->set_closure(*function);
 776   context->set_previous(*previous);
 777   context->set_extension(*extension);
 778   context->set_global_object(previous->global_object());
 779   return context;
 780 }
 781
 782
 783 Handle<Context> Factory::NewBlockContext(Handle<JSFunction> function,
 784                                          Handle<Context> previous,
 785                                          Handle<ScopeInfo> scope_info) {
 786   Handle<FixedArray> array =
 787       NewFixedArrayWithHoles(scope_info->ContextLength());
 788   array->set_map_no_write_barrier(*block_context_map());
 789   Handle<Context> context = Handle<Context>::cast(array);
 790   context->set_closure(*function);
 791   context->set_previous(*previous);
 792   context->set_extension(*scope_info);
 793   context->set_global_object(previous->global_object());
 794   return context;
 795 }
 796
 797
 798 Handle<Struct> Factory::NewStruct(InstanceType type) {
 799   CALL_HEAP_FUNCTION(
 800       isolate(),
 801       isolate()->heap()->AllocateStruct(type),
 802       Struct);
 803 }
 804
 805
 806 Handle<CodeCache> Factory::NewCodeCache() {
 807   Handle<CodeCache> code_cache =
 808       Handle<CodeCache>::cast(NewStruct(CODE_CACHE_TYPE));
 809   code_cache->set_default_cache(*empty_fixed_array(), SKIP_WRITE_BARRIER);
 810   code_cache->set_normal_type_cache(*undefined_value(), SKIP_WRITE_BARRIER);
 811   return code_cache;
 812 }
 813
 814
 815 Handle<AliasedArgumentsEntry> Factory::NewAliasedArgumentsEntry(
 816     int aliased_context_slot) {
 817   Handle<AliasedArgumentsEntry> entry = Handle<AliasedArgumentsEntry>::cast(
 818       NewStruct(ALIASED_ARGUMENTS_ENTRY_TYPE));
 819   entry->set_aliased_context_slot(aliased_context_slot);
 820   return entry;
 821 }
 822
 823
 824 Handle<ExecutableAccessorInfo> Factory::NewExecutableAccessorInfo() {
 825   Handle<ExecutableAccessorInfo> info =
 826       Handle<ExecutableAccessorInfo>::cast(
 827           NewStruct(EXECUTABLE_ACCESSOR_INFO_TYPE));
 828   info->set_flag(0);  // Must clear the flag, it was initialized as undefined.
 829   return info;
 830 }
 831
 832
 833 Handle<Script> Factory::NewScript(Handle<String> source) {
 834   // Create and initialize script object.
 835   Heap* heap = isolate()->heap();
 836   Handle<Script> script = Handle<Script>::cast(NewStruct(SCRIPT_TYPE));
 837   script->set_source(*source);
 838   script->set_name(heap->undefined_value());
 839   script->set_id(isolate()->heap()->NextScriptId());
 840   script->set_line_offset(Smi::FromInt(0));
 841   script->set_column_offset(Smi::FromInt(0));
 842   script->set_context_data(heap->undefined_value());
 843   script->set_type(Smi::FromInt(Script::TYPE_NORMAL));
 844   script->set_wrapper(heap->undefined_value());
 845   script->set_line_ends(heap->undefined_value());
 846   script->set_eval_from_shared(heap->undefined_value());
 847   script->set_eval_from_instructions_offset(Smi::FromInt(0));
 848   script->set_shared_function_infos(Smi::FromInt(0));
 849   script->set_flags(Smi::FromInt(0));
 850
 851   return script;
 852 }
 853
 854
 855 Handle<Foreign> Factory::NewForeign(Address addr, PretenureFlag pretenure) {
 856   CALL_HEAP_FUNCTION(isolate(),
 857                      isolate()->heap()->AllocateForeign(addr, pretenure),
 858                      Foreign);
 859 }
 860
 861
 862 Handle<Foreign> Factory::NewForeign(const AccessorDescriptor* desc) {
 863   return NewForeign((Address) desc, TENURED);
 864 }
 865
 866
 867 Handle<ByteArray> Factory::NewByteArray(int length, PretenureFlag pretenure) {
 868   DCHECK(0 <= length);
 869   CALL_HEAP_FUNCTION(
 870       isolate(),
 871       isolate()->heap()->AllocateByteArray(length, pretenure),
 872       ByteArray);
 873 }
 874
 875
 876 Handle<BytecodeArray> Factory::NewBytecodeArray(int length,
 877                                                 const byte* raw_bytecodes,
 878                                                 int frame_size) {
 879   DCHECK(0 <= length);
 880   CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->AllocateBytecodeArray(
 881                                     length, raw_bytecodes, frame_size),
 882                      BytecodeArray);
 883 }
 884
 885
 886 Handle<FixedTypedArrayBase> Factory::NewFixedTypedArrayWithExternalPointer(
 887     int length, ExternalArrayType array_type, void* external_pointer,
 888     PretenureFlag pretenure) {
 889   DCHECK(0 <= length && length <= Smi::kMaxValue);
 890   CALL_HEAP_FUNCTION(
 891       isolate(), isolate()->heap()->AllocateFixedTypedArrayWithExternalPointer(
 892                      length, array_type, external_pointer, pretenure),
 893       FixedTypedArrayBase);
 894 }
 895
 896
 897 Handle<FixedTypedArrayBase> Factory::NewFixedTypedArray(
 898     int length, ExternalArrayType array_type, bool initialize,
 899     PretenureFlag pretenure) {
 900   DCHECK(0 <= length && length <= Smi::kMaxValue);
 901   CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->AllocateFixedTypedArray(
 902                                     length, array_type, initialize, pretenure),
 903                      FixedTypedArrayBase);
 904 }
 905
 906
 907 Handle<Cell> Factory::NewCell(Handle<Object> value) {
 908   AllowDeferredHandleDereference convert_to_cell;
 909   CALL_HEAP_FUNCTION(
 910       isolate(),
 911       isolate()->heap()->AllocateCell(*value),
 912       Cell);
 913 }
 914
 915
 916 Handle<PropertyCell> Factory::NewPropertyCell() {
 917   CALL_HEAP_FUNCTION(
 918       isolate(),
 919       isolate()->heap()->AllocatePropertyCell(),
 920       PropertyCell);
 921 }
 922
 923
 924 Handle<WeakCell> Factory::NewWeakCell(Handle<HeapObject> value) {
 925   // It is safe to dereference the value because we are embedding it
 926   // in cell and not inspecting its fields.
 927   AllowDeferredHandleDereference convert_to_cell;
 928   CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->AllocateWeakCell(*value),
 929                      WeakCell);
 930 }
 931
 932
 933 Handle<AllocationSite> Factory::NewAllocationSite() {
 934   Handle<Map> map = allocation_site_map();
 935   Handle<AllocationSite> site = New<AllocationSite>(map, OLD_SPACE);
 936   site->Initialize();
 937
 938   // Link the site
 939   site->set_weak_next(isolate()->heap()->allocation_sites_list());
 940   isolate()->heap()->set_allocation_sites_list(*site);
 941   return site;
 942 }
 943
 944
 945 Handle<Map> Factory::NewMap(InstanceType type,
 946                             int instance_size,
 947                             ElementsKind elements_kind) {
 948   CALL_HEAP_FUNCTION(
 949       isolate(),
 950       isolate()->heap()->AllocateMap(type, instance_size, elements_kind),
 951       Map);
 952 }
 953
 954
 955 Handle<JSObject> Factory::CopyJSObject(Handle<JSObject> object) {
 956   CALL_HEAP_FUNCTION(isolate(),
 957                      isolate()->heap()->CopyJSObject(*object, NULL),
 958                      JSObject);
 959 }
 960
 961
 962 Handle<JSObject> Factory::CopyJSObjectWithAllocationSite(
 963     Handle<JSObject> object,
 964     Handle<AllocationSite> site) {
 965   CALL_HEAP_FUNCTION(isolate(),
 966                      isolate()->heap()->CopyJSObject(
 967                          *object,
 968                          site.is_null() ? NULL : *site),
 969                      JSObject);
 970 }
 971
 972
 973 Handle<FixedArray> Factory::CopyFixedArrayWithMap(Handle<FixedArray> array,
 974                                                   Handle<Map> map) {
 975   CALL_HEAP_FUNCTION(isolate(),
 976                      isolate()->heap()->CopyFixedArrayWithMap(*array, *map),
 977                      FixedArray);
 978 }
 979
 980
 981 Handle<FixedArray> Factory::CopyFixedArrayAndGrow(Handle<FixedArray> array,
 982                                                   int grow_by,
 983                                                   PretenureFlag pretenure) {
 984   CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->CopyFixedArrayAndGrow(
 985                                     *array, grow_by, pretenure),
 986                      FixedArray);
 987 }
 988
 989
 990 Handle<FixedArray> Factory::CopyFixedArray(Handle<FixedArray> array) {
 991   CALL_HEAP_FUNCTION(isolate(),
 992                      isolate()->heap()->CopyFixedArray(*array),
 993                      FixedArray);
 994 }
 995
 996
 997 Handle<FixedArray> Factory::CopyAndTenureFixedCOWArray(
 998     Handle<FixedArray> array) {
 999   DCHECK(isolate()->heap()->InNewSpace(*array));
1000   CALL_HEAP_FUNCTION(isolate(),
1001                      isolate()->heap()->CopyAndTenureFixedCOWArray(*array),
1002                      FixedArray);
1003 }
1004
1005
1006 Handle<FixedDoubleArray> Factory::CopyFixedDoubleArray(
1007     Handle<FixedDoubleArray> array) {
1008   CALL_HEAP_FUNCTION(isolate(),
1009                      isolate()->heap()->CopyFixedDoubleArray(*array),
1010                      FixedDoubleArray);
1011 }
1012
1013
1014 Handle<Object> Factory::NewNumber(double value,
1015                                   PretenureFlag pretenure) {
1016   // We need to distinguish the minus zero value and this cannot be
1017   // done after conversion to int. Doing this by comparing bit
1018   // patterns is faster than using fpclassify() et al.
1019   if (IsMinusZero(value)) return NewHeapNumber(-0.0, IMMUTABLE, pretenure);
1020
1021   int int_value = FastD2IChecked(value);
1022   if (value == int_value && Smi::IsValid(int_value)) {
1023     return handle(Smi::FromInt(int_value), isolate());
1024   }
1025
1026   // Materialize the value in the heap.
1027   return NewHeapNumber(value, IMMUTABLE, pretenure);
1028 }
1029
1030
1031 Handle<Object> Factory::NewNumberFromInt(int32_t value,
1032                                          PretenureFlag pretenure) {
1033   if (Smi::IsValid(value)) return handle(Smi::FromInt(value), isolate());
1034   // Bypass NewNumber to avoid various redundant checks.
1035   return NewHeapNumber(FastI2D(value), IMMUTABLE, pretenure);
1036 }
1037
1038
1039 Handle<Object> Factory::NewNumberFromUint(uint32_t value,
1040                                           PretenureFlag pretenure) {
1041   int32_t int32v = static_cast<int32_t>(value);
1042   if (int32v >= 0 && Smi::IsValid(int32v)) {
1043     return handle(Smi::FromInt(int32v), isolate());
1044   }
1045   return NewHeapNumber(FastUI2D(value), IMMUTABLE, pretenure);
1046 }
1047
1048
1049 Handle<HeapNumber> Factory::NewHeapNumber(double value,
1050                                           MutableMode mode,
1051                                           PretenureFlag pretenure) {
1052   CALL_HEAP_FUNCTION(
1053       isolate(),
1054       isolate()->heap()->AllocateHeapNumber(value, mode, pretenure),
1055       HeapNumber);
1056 }
1057
1058
1059 Handle<Float32x4> Factory::NewFloat32x4(float lanes[4],
1060                                         PretenureFlag pretenure) {
1061   CALL_HEAP_FUNCTION(isolate(),
1062                      isolate()->heap()->AllocateFloat32x4(lanes, pretenure),
1063                      Float32x4);
1064 }
1065
1066
1067 Handle<Int32x4> Factory::NewInt32x4(int32_t lanes[4], PretenureFlag pretenure) {
1068   CALL_HEAP_FUNCTION(
1069       isolate(), isolate()->heap()->AllocateInt32x4(lanes, pretenure), Int32x4);
1070 }
1071
1072
1073 Handle<Bool32x4> Factory::NewBool32x4(bool lanes[4], PretenureFlag pretenure) {
1074   CALL_HEAP_FUNCTION(isolate(),
1075                      isolate()->heap()->AllocateBool32x4(lanes, pretenure),
1076                      Bool32x4);
1077 }
1078
1079
1080 Handle<Int16x8> Factory::NewInt16x8(int16_t lanes[8], PretenureFlag pretenure) {
1081   CALL_HEAP_FUNCTION(
1082       isolate(), isolate()->heap()->AllocateInt16x8(lanes, pretenure), Int16x8);
1083 }
1084
1085
1086 Handle<Bool16x8> Factory::NewBool16x8(bool lanes[8], PretenureFlag pretenure) {
1087   CALL_HEAP_FUNCTION(isolate(),
1088                      isolate()->heap()->AllocateBool16x8(lanes, pretenure),
1089                      Bool16x8);
1090 }
1091
1092
1093 Handle<Int8x16> Factory::NewInt8x16(int8_t lanes[16], PretenureFlag pretenure) {
1094   CALL_HEAP_FUNCTION(
1095       isolate(), isolate()->heap()->AllocateInt8x16(lanes, pretenure), Int8x16);
1096 }
1097
1098
1099 Handle<Bool8x16> Factory::NewBool8x16(bool lanes[16], PretenureFlag pretenure) {
1100   CALL_HEAP_FUNCTION(isolate(),
1101                      isolate()->heap()->AllocateBool8x16(lanes, pretenure),
1102                      Bool8x16);
1103 }
1104
1105
1106 Handle<Object> Factory::NewError(const char* maker,
1107                                  MessageTemplate::Template template_index,
1108                                  Handle<Object> arg0, Handle<Object> arg1,
1109                                  Handle<Object> arg2) {
1110   HandleScope scope(isolate());
1111   Handle<String> error_maker = InternalizeUtf8String(maker);
1112   if (isolate()->bootstrapper()->IsActive()) {
1113     // If this exception is being thrown during bootstrapping,
1114     // js_builtins_object is unavailable. We return the error maker
1115     // name's string as the exception since we have nothing better
1116     // to do.
1117     return scope.CloseAndEscape(error_maker);
1118   }
1119   Handle<Object> fun_obj = Object::GetProperty(isolate()->js_builtins_object(),
1120                                                error_maker).ToHandleChecked();
1121
1122   Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
1123   Handle<Object> message_type(Smi::FromInt(template_index), isolate());
1124   if (arg0.is_null()) arg0 = undefined_value();
1125   if (arg1.is_null()) arg1 = undefined_value();
1126   if (arg2.is_null()) arg2 = undefined_value();
1127   Handle<Object> argv[] = {message_type, arg0, arg1, arg2};
1128
1129   // Invoke the JavaScript factory method. If an exception is thrown while
1130   // running the factory method, use the exception as the result.
1131   Handle<Object> result;
1132   MaybeHandle<Object> exception;
1133   if (!Execution::TryCall(fun, isolate()->js_builtins_object(), arraysize(argv),
1134                           argv, &exception).ToHandle(&result)) {
1135     Handle<Object> exception_obj;
1136     if (exception.ToHandle(&exception_obj)) {
1137       result = exception_obj;
1138     } else {
1139       result = undefined_value();
1140     }
1141   }
1142   return scope.CloseAndEscape(result);
1143 }
1144
1145
1146 Handle<Object> Factory::NewError(MessageTemplate::Template template_index,
1147                                  Handle<Object> arg0, Handle<Object> arg1,
1148                                  Handle<Object> arg2) {
1149   return NewError("MakeError", template_index, arg0, arg1, arg2);
1150 }
1151
1152
1153 Handle<Object> Factory::NewTypeError(MessageTemplate::Template template_index,
1154                                      Handle<Object> arg0, Handle<Object> arg1,
1155                                      Handle<Object> arg2) {
1156   return NewError("MakeTypeError", template_index, arg0, arg1, arg2);
1157 }
1158
1159
1160 Handle<Object> Factory::NewSyntaxError(MessageTemplate::Template template_index,
1161                                        Handle<Object> arg0, Handle<Object> arg1,
1162                                        Handle<Object> arg2) {
1163   return NewError("MakeSyntaxError", template_index, arg0, arg1, arg2);
1164 }
1165
1166
1167 Handle<Object> Factory::NewReferenceError(
1168     MessageTemplate::Template template_index, Handle<Object> arg0,
1169     Handle<Object> arg1, Handle<Object> arg2) {
1170   return NewError("MakeReferenceError", template_index, arg0, arg1, arg2);
1171 }
1172
1173
1174 Handle<Object> Factory::NewRangeError(MessageTemplate::Template template_index,
1175                                       Handle<Object> arg0, Handle<Object> arg1,
1176                                       Handle<Object> arg2) {
1177   return NewError("MakeRangeError", template_index, arg0, arg1, arg2);
1178 }
1179
1180
1181 Handle<Object> Factory::NewEvalError(MessageTemplate::Template template_index,
1182                                      Handle<Object> arg0, Handle<Object> arg1,
1183                                      Handle<Object> arg2) {
1184   return NewError("MakeEvalError", template_index, arg0, arg1, arg2);
1185 }
1186
1187
1188 Handle<String> Factory::EmergencyNewError(const char* message,
1189                                           Handle<JSArray> args) {
1190   const int kBufferSize = 1000;
1191   char buffer[kBufferSize];
1192   size_t space = kBufferSize;
1193   char* p = &buffer[0];
1194
1195   Vector<char> v(buffer, kBufferSize);
1196   StrNCpy(v, message, space);
1197   space -= Min(space, strlen(message));
1198   p = &buffer[kBufferSize] - space;
1199
1200   for (int i = 0; i < Smi::cast(args->length())->value(); i++) {
1201     if (space > 0) {
1202       *p++ = ' ';
1203       space--;
1204       if (space > 0) {
1205         Handle<String> arg_str = Handle<String>::cast(
1206             Object::GetElement(isolate(), args, i).ToHandleChecked());
1207         base::SmartArrayPointer<char> arg = arg_str->ToCString();
1208         Vector<char> v2(p, static_cast<int>(space));
1209         StrNCpy(v2, arg.get(), space);
1210         space -= Min(space, strlen(arg.get()));
1211         p = &buffer[kBufferSize] - space;
1212       }
1213     }
1214   }
1215   if (space > 0) {
1216     *p = '\0';
1217   } else {
1218     buffer[kBufferSize - 1] = '\0';
1219   }
1220   return NewStringFromUtf8(CStrVector(buffer), TENURED).ToHandleChecked();
1221 }
1222
1223
1224 Handle<Object> Factory::NewError(const char* maker, const char* message,
1225                                  Handle<JSArray> args) {
1226   Handle<String> make_str = InternalizeUtf8String(maker);
1227   Handle<Object> fun_obj = Object::GetProperty(
1228       isolate()->js_builtins_object(), make_str).ToHandleChecked();
1229   // If the builtins haven't been properly configured yet this error
1230   // constructor may not have been defined.  Bail out.
1231   if (!fun_obj->IsJSFunction()) {
1232     return EmergencyNewError(message, args);
1233   }
1234   Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
1235   Handle<Object> message_obj = InternalizeUtf8String(message);
1236   Handle<Object> argv[] = { message_obj, args };
1237
1238   // Invoke the JavaScript factory method. If an exception is thrown while
1239   // running the factory method, use the exception as the result.
1240   Handle<Object> result;
1241   MaybeHandle<Object> exception;
1242   if (!Execution::TryCall(fun,
1243                           isolate()->js_builtins_object(),
1244                           arraysize(argv),
1245                           argv,
1246                           &exception).ToHandle(&result)) {
1247     Handle<Object> exception_obj;
1248     if (exception.ToHandle(&exception_obj)) return exception_obj;
1249     return undefined_value();
1250   }
1251   return result;
1252 }
1253
1254
1255 Handle<Object> Factory::NewError(const char* constructor,
1256                                  Handle<String> message) {
1257   Handle<String> constr = InternalizeUtf8String(constructor);
1258   Handle<JSFunction> fun = Handle<JSFunction>::cast(Object::GetProperty(
1259       isolate()->js_builtins_object(), constr).ToHandleChecked());
1260   Handle<Object> argv[] = { message };
1261
1262   // Invoke the JavaScript factory method. If an exception is thrown while
1263   // running the factory method, use the exception as the result.
1264   Handle<Object> result;
1265   MaybeHandle<Object> exception;
1266   if (!Execution::TryCall(fun,
1267                           isolate()->js_builtins_object(),
1268                           arraysize(argv),
1269                           argv,
1270                           &exception).ToHandle(&result)) {
1271     Handle<Object> exception_obj;
1272     if (exception.ToHandle(&exception_obj)) return exception_obj;
1273     return undefined_value();
1274   }
1275   return result;
1276 }
1277
1278
1279 void Factory::InitializeFunction(Handle<JSFunction> function,
1280                                  Handle<SharedFunctionInfo> info,
1281                                  Handle<Context> context) {
1282   function->initialize_properties();
1283   function->initialize_elements();
1284   function->set_shared(*info);
1285   function->set_code(info->code());
1286   function->set_context(*context);
1287   function->set_prototype_or_initial_map(*the_hole_value());
1288   function->set_literals_or_bindings(*empty_fixed_array());
1289   function->set_next_function_link(*undefined_value(), SKIP_WRITE_BARRIER);
1290 }
1291
1292
1293 Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
1294                                         Handle<SharedFunctionInfo> info,
1295                                         Handle<Context> context,
1296                                         PretenureFlag pretenure) {
1297   AllocationSpace space = pretenure == TENURED ? OLD_SPACE : NEW_SPACE;
1298   Handle<JSFunction> result = New<JSFunction>(map, space);
1299   InitializeFunction(result, info, context);
1300   return result;
1301 }
1302
1303
1304 Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
1305                                         Handle<String> name,
1306                                         MaybeHandle<Code> code) {
1307   Handle<Context> context(isolate()->native_context());
1308   Handle<SharedFunctionInfo> info = NewSharedFunctionInfo(name, code);
1309   DCHECK(is_sloppy(info->language_mode()) &&
1310          (map.is_identical_to(isolate()->sloppy_function_map()) ||
1311           map.is_identical_to(
1312               isolate()->sloppy_function_without_prototype_map()) ||
1313           map.is_identical_to(
1314               isolate()->sloppy_function_with_readonly_prototype_map()) ||
1315           map.is_identical_to(isolate()->strict_function_map())));
1316   return NewFunction(map, info, context);
1317 }
1318
1319
1320 Handle<JSFunction> Factory::NewFunction(Handle<String> name) {
1321   return NewFunction(
1322       isolate()->sloppy_function_map(), name, MaybeHandle<Code>());
1323 }
1324
1325
1326 Handle<JSFunction> Factory::NewFunctionWithoutPrototype(Handle<String> name,
1327                                                         Handle<Code> code,
1328                                                         bool is_strict) {
1329   Handle<Map> map = is_strict
1330                         ? isolate()->strict_function_without_prototype_map()
1331                         : isolate()->sloppy_function_without_prototype_map();
1332   return NewFunction(map, name, code);
1333 }
1334
1335
1336 Handle<JSFunction> Factory::NewFunction(Handle<String> name, Handle<Code> code,
1337                                         Handle<Object> prototype,
1338                                         bool read_only_prototype,
1339                                         bool is_strict) {
1340   // In strict mode, readonly strict map is only available during bootstrap
1341   DCHECK(!is_strict || !read_only_prototype ||
1342          isolate()->bootstrapper()->IsActive());
1343   Handle<Map> map =
1344       is_strict ? isolate()->strict_function_map()
1345                 : read_only_prototype
1346                       ? isolate()->sloppy_function_with_readonly_prototype_map()
1347                       : isolate()->sloppy_function_map();
1348   Handle<JSFunction> result = NewFunction(map, name, code);
1349   result->set_prototype_or_initial_map(*prototype);
1350   return result;
1351 }
1352
1353
1354 Handle<JSFunction> Factory::NewFunction(Handle<String> name, Handle<Code> code,
1355                                         Handle<Object> prototype,
1356                                         InstanceType type, int instance_size,
1357                                         bool read_only_prototype,
1358                                         bool install_constructor,
1359                                         bool is_strict) {
1360   // Allocate the function
1361   Handle<JSFunction> function =
1362       NewFunction(name, code, prototype, read_only_prototype, is_strict);
1363
1364   ElementsKind elements_kind =
1365       type == JS_ARRAY_TYPE ? FAST_SMI_ELEMENTS : FAST_HOLEY_SMI_ELEMENTS;
1366   Handle<Map> initial_map = NewMap(type, instance_size, elements_kind);
1367   if (!function->shared()->is_generator()) {
1368     if (prototype->IsTheHole()) {
1369       prototype = NewFunctionPrototype(function);
1370     } else if (install_constructor) {
1371       JSObject::AddProperty(Handle<JSObject>::cast(prototype),
1372                             constructor_string(), function, DONT_ENUM);
1373     }
1374   }
1375
1376   JSFunction::SetInitialMap(function, initial_map,
1377                             Handle<JSReceiver>::cast(prototype));
1378
1379   return function;
1380 }
1381
1382
1383 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
1384                                         Handle<Code> code,
1385                                         InstanceType type,
1386                                         int instance_size) {
1387   return NewFunction(name, code, the_hole_value(), type, instance_size);
1388 }
1389
1390
1391 Handle<JSObject> Factory::NewFunctionPrototype(Handle<JSFunction> function) {
1392   // Make sure to use globals from the function's context, since the function
1393   // can be from a different context.
1394   Handle<Context> native_context(function->context()->native_context());
1395   Handle<Map> new_map;
1396   if (function->shared()->is_generator()) {
1397     // Generator prototypes can share maps since they don't have "constructor"
1398     // properties.
1399     new_map = handle(native_context->generator_object_prototype_map());
1400   } else {
1401     // Each function prototype gets a fresh map to avoid unwanted sharing of
1402     // maps between prototypes of different constructors.
1403     Handle<JSFunction> object_function(native_context->object_function());
1404     DCHECK(object_function->has_initial_map());
1405     new_map = handle(object_function->initial_map());
1406   }
1407
1408   DCHECK(!new_map->is_prototype_map());
1409   Handle<JSObject> prototype = NewJSObjectFromMap(new_map);
1410
1411   if (!function->shared()->is_generator()) {
1412     JSObject::AddProperty(prototype, constructor_string(), function, DONT_ENUM);
1413   }
1414
1415   return prototype;
1416 }
1417
1418
1419 Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
1420     Handle<SharedFunctionInfo> info,
1421     Handle<Context> context,
1422     PretenureFlag pretenure) {
1423   int map_index =
1424       Context::FunctionMapIndex(info->language_mode(), info->kind());
1425   Handle<Map> map(Map::cast(context->native_context()->get(map_index)));
1426   Handle<JSFunction> result = NewFunction(map, info, context, pretenure);
1427
1428   if (info->ic_age() != isolate()->heap()->global_ic_age()) {
1429     info->ResetForNewContext(isolate()->heap()->global_ic_age());
1430   }
1431
1432   if (FLAG_always_opt && info->allows_lazy_compilation()) {
1433     result->MarkForOptimization();
1434   }
1435
1436   CodeAndLiterals cached = info->SearchOptimizedCodeMap(
1437       context->native_context(), BailoutId::None());
1438   if (cached.code != nullptr) {
1439     // Caching of optimized code enabled and optimized code found.
1440     if (cached.literals != nullptr) result->set_literals(cached.literals);
1441     DCHECK(!cached.code->marked_for_deoptimization());
1442     DCHECK(result->shared()->is_compiled());
1443     result->ReplaceCode(cached.code);
1444   }
1445
1446   if (cached.literals == nullptr && !info->bound()) {
1447     int number_of_literals = info->num_literals();
1448     // TODO(mstarzinger): Consider sharing the newly created literals array.
1449     Handle<FixedArray> literals = NewFixedArray(number_of_literals, pretenure);
1450     result->set_literals(*literals);
1451   }
1452
1453   return result;
1454 }
1455
1456
1457 Handle<ScopeInfo> Factory::NewScopeInfo(int length) {
1458   Handle<FixedArray> array = NewFixedArray(length, TENURED);
1459   array->set_map_no_write_barrier(*scope_info_map());
1460   Handle<ScopeInfo> scope_info = Handle<ScopeInfo>::cast(array);
1461   return scope_info;
1462 }
1463
1464
1465 Handle<JSObject> Factory::NewExternal(void* value) {
1466   Handle<Foreign> foreign = NewForeign(static_cast<Address>(value));
1467   Handle<JSObject> external = NewJSObjectFromMap(external_map());
1468   external->SetInternalField(0, *foreign);
1469   return external;
1470 }
1471
1472
1473 Handle<Code> Factory::NewCodeRaw(int object_size, bool immovable) {
1474   CALL_HEAP_FUNCTION(isolate(),
1475                      isolate()->heap()->AllocateCode(object_size, immovable),
1476                      Code);
1477 }
1478
1479
1480 Handle<Code> Factory::NewCode(const CodeDesc& desc,
1481                               Code::Flags flags,
1482                               Handle<Object> self_ref,
1483                               bool immovable,
1484                               bool crankshafted,
1485                               int prologue_offset,
1486                               bool is_debug) {
1487   Handle<ByteArray> reloc_info = NewByteArray(desc.reloc_size, TENURED);
1488
1489   // Compute size.
1490   int body_size = RoundUp(desc.instr_size, kObjectAlignment);
1491   int obj_size = Code::SizeFor(body_size);
1492
1493   Handle<Code> code = NewCodeRaw(obj_size, immovable);
1494   DCHECK(isolate()->code_range() == NULL || !isolate()->code_range()->valid() ||
1495          isolate()->code_range()->contains(code->address()) ||
1496          obj_size <= isolate()->heap()->code_space()->AreaSize());
1497
1498   // The code object has not been fully initialized yet.  We rely on the
1499   // fact that no allocation will happen from this point on.
1500   DisallowHeapAllocation no_gc;
1501   code->set_gc_metadata(Smi::FromInt(0));
1502   code->set_ic_age(isolate()->heap()->global_ic_age());
1503   code->set_instruction_size(desc.instr_size);
1504   code->set_relocation_info(*reloc_info);
1505   code->set_flags(flags);
1506   code->set_raw_kind_specific_flags1(0);
1507   code->set_raw_kind_specific_flags2(0);
1508   code->set_is_crankshafted(crankshafted);
1509   code->set_deoptimization_data(*empty_fixed_array(), SKIP_WRITE_BARRIER);
1510   code->set_raw_type_feedback_info(Smi::FromInt(0));
1511   code->set_next_code_link(*undefined_value());
1512   code->set_handler_table(*empty_fixed_array(), SKIP_WRITE_BARRIER);
1513   code->set_prologue_offset(prologue_offset);
1514   if (FLAG_enable_embedded_constant_pool) {
1515     code->set_constant_pool_offset(desc.instr_size - desc.constant_pool_size);
1516   }
1517   if (code->kind() == Code::OPTIMIZED_FUNCTION) {
1518     code->set_marked_for_deoptimization(false);
1519   }
1520
1521   if (is_debug) {
1522     DCHECK(code->kind() == Code::FUNCTION);
1523     code->set_has_debug_break_slots(true);
1524   }
1525
1526   // Allow self references to created code object by patching the handle to
1527   // point to the newly allocated Code object.
1528   if (!self_ref.is_null()) *(self_ref.location()) = *code;
1529
1530   // Migrate generated code.
1531   // The generated code can contain Object** values (typically from handles)
1532   // that are dereferenced during the copy to point directly to the actual heap
1533   // objects. These pointers can include references to the code object itself,
1534   // through the self_reference parameter.
1535   code->CopyFrom(desc);
1536
1537 #ifdef VERIFY_HEAP
1538   if (FLAG_verify_heap) code->ObjectVerify();
1539 #endif
1540   return code;
1541 }
1542
1543
1544 Handle<Code> Factory::CopyCode(Handle<Code> code) {
1545   CALL_HEAP_FUNCTION(isolate(),
1546                      isolate()->heap()->CopyCode(*code),
1547                      Code);
1548 }
1549
1550
1551 Handle<Code> Factory::CopyCode(Handle<Code> code, Vector<byte> reloc_info) {
1552   CALL_HEAP_FUNCTION(isolate(),
1553                      isolate()->heap()->CopyCode(*code, reloc_info),
1554                      Code);
1555 }
1556
1557
1558 Handle<JSObject> Factory::NewJSObject(Handle<JSFunction> constructor,
1559                                       PretenureFlag pretenure) {
1560   JSFunction::EnsureHasInitialMap(constructor);
1561   CALL_HEAP_FUNCTION(
1562       isolate(),
1563       isolate()->heap()->AllocateJSObject(*constructor, pretenure), JSObject);
1564 }
1565
1566
1567 Handle<JSObject> Factory::NewJSObjectWithMemento(
1568     Handle<JSFunction> constructor,
1569     Handle<AllocationSite> site) {
1570   JSFunction::EnsureHasInitialMap(constructor);
1571   CALL_HEAP_FUNCTION(
1572       isolate(),
1573       isolate()->heap()->AllocateJSObject(*constructor, NOT_TENURED, *site),
1574       JSObject);
1575 }
1576
1577
1578 Handle<JSModule> Factory::NewJSModule(Handle<Context> context,
1579                                       Handle<ScopeInfo> scope_info) {
1580   // Allocate a fresh map. Modules do not have a prototype.
1581   Handle<Map> map = NewMap(JS_MODULE_TYPE, JSModule::kSize);
1582   // Allocate the object based on the map.
1583   Handle<JSModule> module =
1584       Handle<JSModule>::cast(NewJSObjectFromMap(map, TENURED));
1585   module->set_context(*context);
1586   module->set_scope_info(*scope_info);
1587   return module;
1588 }
1589
1590
1591 Handle<GlobalObject> Factory::NewGlobalObject(Handle<JSFunction> constructor) {
1592   DCHECK(constructor->has_initial_map());
1593   Handle<Map> map(constructor->initial_map());
1594   DCHECK(map->is_dictionary_map());
1595
1596   // Make sure no field properties are described in the initial map.
1597   // This guarantees us that normalizing the properties does not
1598   // require us to change property values to PropertyCells.
1599   DCHECK(map->NextFreePropertyIndex() == 0);
1600
1601   // Make sure we don't have a ton of pre-allocated slots in the
1602   // global objects. They will be unused once we normalize the object.
1603   DCHECK(map->unused_property_fields() == 0);
1604   DCHECK(map->inobject_properties() == 0);
1605
1606   // Initial size of the backing store to avoid resize of the storage during
1607   // bootstrapping. The size differs between the JS global object ad the
1608   // builtins object.
1609   int initial_size = map->instance_type() == JS_GLOBAL_OBJECT_TYPE ? 64 : 512;
1610
1611   // Allocate a dictionary object for backing storage.
1612   int at_least_space_for = map->NumberOfOwnDescriptors() * 2 + initial_size;
1613   Handle<GlobalDictionary> dictionary =
1614       GlobalDictionary::New(isolate(), at_least_space_for);
1615
1616   // The global object might be created from an object template with accessors.
1617   // Fill these accessors into the dictionary.
1618   Handle<DescriptorArray> descs(map->instance_descriptors());
1619   for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {
1620     PropertyDetails details = descs->GetDetails(i);
1621     // Only accessors are expected.
1622     DCHECK_EQ(ACCESSOR_CONSTANT, details.type());
1623     PropertyDetails d(details.attributes(), ACCESSOR_CONSTANT, i + 1,
1624                       PropertyCellType::kMutable);
1625     Handle<Name> name(descs->GetKey(i));
1626     Handle<PropertyCell> cell = NewPropertyCell();
1627     cell->set_value(descs->GetCallbacksObject(i));
1628     // |dictionary| already contains enough space for all properties.
1629     USE(GlobalDictionary::Add(dictionary, name, cell, d));
1630   }
1631
1632   // Allocate the global object and initialize it with the backing store.
1633   Handle<GlobalObject> global = New<GlobalObject>(map, OLD_SPACE);
1634   isolate()->heap()->InitializeJSObjectFromMap(*global, *dictionary, *map);
1635
1636   // Create a new map for the global object.
1637   Handle<Map> new_map = Map::CopyDropDescriptors(map);
1638   new_map->set_dictionary_map(true);
1639
1640   // Set up the global object as a normalized object.
1641   global->set_map(*new_map);
1642   global->set_properties(*dictionary);
1643
1644   // Make sure result is a global object with properties in dictionary.
1645   DCHECK(global->IsGlobalObject() && !global->HasFastProperties());
1646   return global;
1647 }
1648
1649
1650 Handle<JSObject> Factory::NewJSObjectFromMap(
1651     Handle<Map> map,
1652     PretenureFlag pretenure,
1653     Handle<AllocationSite> allocation_site) {
1654   CALL_HEAP_FUNCTION(
1655       isolate(),
1656       isolate()->heap()->AllocateJSObjectFromMap(
1657           *map,
1658           pretenure,
1659           allocation_site.is_null() ? NULL : *allocation_site),
1660       JSObject);
1661 }
1662
1663
1664 Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind,
1665                                     Strength strength,
1666                                     PretenureFlag pretenure) {
1667   Map* map = isolate()->get_initial_js_array_map(elements_kind, strength);
1668   if (map == nullptr) {
1669     DCHECK(strength == Strength::WEAK);
1670     Context* native_context = isolate()->context()->native_context();
1671     JSFunction* array_function = native_context->array_function();
1672     map = array_function->initial_map();
1673   }
1674   return Handle<JSArray>::cast(NewJSObjectFromMap(handle(map), pretenure));
1675 }
1676
1677
1678 Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind, int length,
1679                                     int capacity, Strength strength,
1680                                     ArrayStorageAllocationMode mode,
1681                                     PretenureFlag pretenure) {
1682   Handle<JSArray> array = NewJSArray(elements_kind, strength, pretenure);
1683   NewJSArrayStorage(array, length, capacity, mode);
1684   return array;
1685 }
1686
1687
1688 Handle<JSArray> Factory::NewJSArrayWithElements(Handle<FixedArrayBase> elements,
1689                                                 ElementsKind elements_kind,
1690                                                 int length, Strength strength,
1691                                                 PretenureFlag pretenure) {
1692   DCHECK(length <= elements->length());
1693   Handle<JSArray> array = NewJSArray(elements_kind, strength, pretenure);
1694
1695   array->set_elements(*elements);
1696   array->set_length(Smi::FromInt(length));
1697   JSObject::ValidateElements(array);
1698   return array;
1699 }
1700
1701
1702 void Factory::NewJSArrayStorage(Handle<JSArray> array,
1703                                 int length,
1704                                 int capacity,
1705                                 ArrayStorageAllocationMode mode) {
1706   DCHECK(capacity >= length);
1707
1708   if (capacity == 0) {
1709     array->set_length(Smi::FromInt(0));
1710     array->set_elements(*empty_fixed_array());
1711     return;
1712   }
1713
1714   HandleScope inner_scope(isolate());
1715   Handle<FixedArrayBase> elms;
1716   ElementsKind elements_kind = array->GetElementsKind();
1717   if (IsFastDoubleElementsKind(elements_kind)) {
1718     if (mode == DONT_INITIALIZE_ARRAY_ELEMENTS) {
1719       elms = NewFixedDoubleArray(capacity);
1720     } else {
1721       DCHECK(mode == INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
1722       elms = NewFixedDoubleArrayWithHoles(capacity);
1723     }
1724   } else {
1725     DCHECK(IsFastSmiOrObjectElementsKind(elements_kind));
1726     if (mode == DONT_INITIALIZE_ARRAY_ELEMENTS) {
1727       elms = NewUninitializedFixedArray(capacity);
1728     } else {
1729       DCHECK(mode == INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
1730       elms = NewFixedArrayWithHoles(capacity);
1731     }
1732   }
1733
1734   array->set_elements(*elms);
1735   array->set_length(Smi::FromInt(length));
1736 }
1737
1738
1739 Handle<JSGeneratorObject> Factory::NewJSGeneratorObject(
1740     Handle<JSFunction> function) {
1741   DCHECK(function->shared()->is_generator());
1742   JSFunction::EnsureHasInitialMap(function);
1743   Handle<Map> map(function->initial_map());
1744   DCHECK(map->instance_type() == JS_GENERATOR_OBJECT_TYPE);
1745   CALL_HEAP_FUNCTION(
1746       isolate(),
1747       isolate()->heap()->AllocateJSObjectFromMap(*map),
1748       JSGeneratorObject);
1749 }
1750
1751
1752 Handle<JSArrayBuffer> Factory::NewJSArrayBuffer(SharedFlag shared) {
1753   Handle<JSFunction> array_buffer_fun(
1754       shared == SharedFlag::kShared
1755           ? isolate()->native_context()->shared_array_buffer_fun()
1756           : isolate()->native_context()->array_buffer_fun());
1757   CALL_HEAP_FUNCTION(
1758       isolate(),
1759       isolate()->heap()->AllocateJSObject(*array_buffer_fun),
1760       JSArrayBuffer);
1761 }
1762
1763
1764 Handle<JSDataView> Factory::NewJSDataView() {
1765   Handle<JSFunction> data_view_fun(
1766       isolate()->native_context()->data_view_fun());
1767   CALL_HEAP_FUNCTION(
1768       isolate(),
1769       isolate()->heap()->AllocateJSObject(*data_view_fun),
1770       JSDataView);
1771 }
1772
1773
1774 Handle<JSMap> Factory::NewJSMap() {
1775   Handle<Map> map(isolate()->native_context()->js_map_map());
1776   Handle<JSMap> js_map = Handle<JSMap>::cast(NewJSObjectFromMap(map));
1777   Runtime::JSMapInitialize(isolate(), js_map);
1778   return js_map;
1779 }
1780
1781
1782 Handle<JSSet> Factory::NewJSSet() {
1783   Handle<Map> map(isolate()->native_context()->js_set_map());
1784   Handle<JSSet> js_set = Handle<JSSet>::cast(NewJSObjectFromMap(map));
1785   Runtime::JSSetInitialize(isolate(), js_set);
1786   return js_set;
1787 }
1788
1789
1790 Handle<JSMapIterator> Factory::NewJSMapIterator() {
1791   Handle<Map> map(isolate()->native_context()->map_iterator_map());
1792   CALL_HEAP_FUNCTION(isolate(),
1793                      isolate()->heap()->AllocateJSObjectFromMap(*map),
1794                      JSMapIterator);
1795 }
1796
1797
1798 Handle<JSSetIterator> Factory::NewJSSetIterator() {
1799   Handle<Map> map(isolate()->native_context()->set_iterator_map());
1800   CALL_HEAP_FUNCTION(isolate(),
1801                      isolate()->heap()->AllocateJSObjectFromMap(*map),
1802                      JSSetIterator);
1803 }
1804
1805
1806 namespace {
1807
1808 ElementsKind GetExternalArrayElementsKind(ExternalArrayType type) {
1809   switch (type) {
1810 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
1811   case kExternal##Type##Array:                          \
1812     return TYPE##_ELEMENTS;
1813     TYPED_ARRAYS(TYPED_ARRAY_CASE)
1814   }
1815   UNREACHABLE();
1816   return FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND;
1817 #undef TYPED_ARRAY_CASE
1818 }
1819
1820
1821 size_t GetExternalArrayElementSize(ExternalArrayType type) {
1822   switch (type) {
1823 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
1824   case kExternal##Type##Array:                          \
1825     return size;
1826     TYPED_ARRAYS(TYPED_ARRAY_CASE)
1827     default:
1828       UNREACHABLE();
1829       return 0;
1830   }
1831 #undef TYPED_ARRAY_CASE
1832 }
1833
1834
1835 size_t GetFixedTypedArraysElementSize(ElementsKind kind) {
1836   switch (kind) {
1837 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
1838   case TYPE##_ELEMENTS:                                 \
1839     return size;
1840     TYPED_ARRAYS(TYPED_ARRAY_CASE)
1841     default:
1842       UNREACHABLE();
1843       return 0;
1844   }
1845 #undef TYPED_ARRAY_CASE
1846 }
1847
1848
1849 ExternalArrayType GetArrayTypeFromElementsKind(ElementsKind kind) {
1850   switch (kind) {
1851 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
1852   case TYPE##_ELEMENTS:                                 \
1853     return kExternal##Type##Array;
1854     TYPED_ARRAYS(TYPED_ARRAY_CASE)
1855     default:
1856       UNREACHABLE();
1857       return kExternalInt8Array;
1858   }
1859 #undef TYPED_ARRAY_CASE
1860 }
1861
1862
1863 JSFunction* GetTypedArrayFun(ExternalArrayType type, Isolate* isolate) {
1864   Context* native_context = isolate->context()->native_context();
1865   switch (type) {
1866 #define TYPED_ARRAY_FUN(Type, type, TYPE, ctype, size)                        \
1867     case kExternal##Type##Array:                                              \
1868       return native_context->type##_array_fun();
1869
1870     TYPED_ARRAYS(TYPED_ARRAY_FUN)
1871 #undef TYPED_ARRAY_FUN
1872
1873     default:
1874       UNREACHABLE();
1875       return NULL;
1876   }
1877 }
1878
1879
1880 JSFunction* GetTypedArrayFun(ElementsKind elements_kind, Isolate* isolate) {
1881   Context* native_context = isolate->context()->native_context();
1882   switch (elements_kind) {
1883 #define TYPED_ARRAY_FUN(Type, type, TYPE, ctype, size) \
1884   case TYPE##_ELEMENTS:                                \
1885     return native_context->type##_array_fun();
1886
1887     TYPED_ARRAYS(TYPED_ARRAY_FUN)
1888 #undef TYPED_ARRAY_FUN
1889
1890     default:
1891       UNREACHABLE();
1892       return NULL;
1893   }
1894 }
1895
1896
1897 void SetupArrayBufferView(i::Isolate* isolate,
1898                           i::Handle<i::JSArrayBufferView> obj,
1899                           i::Handle<i::JSArrayBuffer> buffer,
1900                           size_t byte_offset, size_t byte_length) {
1901   DCHECK(byte_offset + byte_length <=
1902          static_cast<size_t>(buffer->byte_length()->Number()));
1903
1904   obj->set_buffer(*buffer);
1905
1906   i::Handle<i::Object> byte_offset_object =
1907       isolate->factory()->NewNumberFromSize(byte_offset);
1908   obj->set_byte_offset(*byte_offset_object);
1909
1910   i::Handle<i::Object> byte_length_object =
1911       isolate->factory()->NewNumberFromSize(byte_length);
1912   obj->set_byte_length(*byte_length_object);
1913 }
1914
1915
1916 }  // namespace
1917
1918
1919 Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type) {
1920   Handle<JSFunction> typed_array_fun_handle(GetTypedArrayFun(type, isolate()));
1921
1922   CALL_HEAP_FUNCTION(
1923       isolate(),
1924       isolate()->heap()->AllocateJSObject(*typed_array_fun_handle),
1925       JSTypedArray);
1926 }
1927
1928
1929 Handle<JSTypedArray> Factory::NewJSTypedArray(ElementsKind elements_kind) {
1930   Handle<JSFunction> typed_array_fun_handle(
1931       GetTypedArrayFun(elements_kind, isolate()));
1932
1933   CALL_HEAP_FUNCTION(
1934       isolate(), isolate()->heap()->AllocateJSObject(*typed_array_fun_handle),
1935       JSTypedArray);
1936 }
1937
1938
1939 Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type,
1940                                               Handle<JSArrayBuffer> buffer,
1941                                               size_t byte_offset,
1942                                               size_t length) {
1943   Handle<JSTypedArray> obj = NewJSTypedArray(type);
1944
1945   size_t element_size = GetExternalArrayElementSize(type);
1946   ElementsKind elements_kind = GetExternalArrayElementsKind(type);
1947
1948   CHECK(byte_offset % element_size == 0);
1949
1950   CHECK(length <= (std::numeric_limits<size_t>::max() / element_size));
1951   CHECK(length <= static_cast<size_t>(Smi::kMaxValue));
1952   size_t byte_length = length * element_size;
1953   SetupArrayBufferView(isolate(), obj, buffer, byte_offset, byte_length);
1954
1955   Handle<Object> length_object = NewNumberFromSize(length);
1956   obj->set_length(*length_object);
1957
1958   Handle<FixedTypedArrayBase> elements = NewFixedTypedArrayWithExternalPointer(
1959       static_cast<int>(length), type,
1960       static_cast<uint8_t*>(buffer->backing_store()) + byte_offset);
1961   Handle<Map> map = JSObject::GetElementsTransitionMap(obj, elements_kind);
1962   JSObject::SetMapAndElements(obj, map, elements);
1963   return obj;
1964 }
1965
1966
1967 Handle<JSTypedArray> Factory::NewJSTypedArray(ElementsKind elements_kind,
1968                                               size_t number_of_elements) {
1969   Handle<JSTypedArray> obj = NewJSTypedArray(elements_kind);
1970
1971   size_t element_size = GetFixedTypedArraysElementSize(elements_kind);
1972   ExternalArrayType array_type = GetArrayTypeFromElementsKind(elements_kind);
1973
1974   CHECK(number_of_elements <=
1975         (std::numeric_limits<size_t>::max() / element_size));
1976   CHECK(number_of_elements <= static_cast<size_t>(Smi::kMaxValue));
1977   size_t byte_length = number_of_elements * element_size;
1978
1979   obj->set_byte_offset(Smi::FromInt(0));
1980   i::Handle<i::Object> byte_length_object =
1981       isolate()->factory()->NewNumberFromSize(byte_length);
1982   obj->set_byte_length(*byte_length_object);
1983   Handle<Object> length_object = NewNumberFromSize(number_of_elements);
1984   obj->set_length(*length_object);
1985
1986   Handle<JSArrayBuffer> buffer = isolate()->factory()->NewJSArrayBuffer();
1987   Runtime::SetupArrayBuffer(isolate(), buffer, true, NULL, byte_length,
1988                             SharedFlag::kNotShared);
1989   obj->set_buffer(*buffer);
1990   Handle<FixedTypedArrayBase> elements =
1991       isolate()->factory()->NewFixedTypedArray(
1992           static_cast<int>(number_of_elements), array_type, true);
1993   obj->set_elements(*elements);
1994   return obj;
1995 }
1996
1997
1998 Handle<JSDataView> Factory::NewJSDataView(Handle<JSArrayBuffer> buffer,
1999                                           size_t byte_offset,
2000                                           size_t byte_length) {
2001   Handle<JSDataView> obj = NewJSDataView();
2002   SetupArrayBufferView(isolate(), obj, buffer, byte_offset, byte_length);
2003   return obj;
2004 }
2005
2006
2007 Handle<JSProxy> Factory::NewJSProxy(Handle<Object> handler,
2008                                     Handle<Object> prototype) {
2009   // Allocate map.
2010   // TODO(rossberg): Once we optimize proxies, think about a scheme to share
2011   // maps. Will probably depend on the identity of the handler object, too.
2012   Handle<Map> map = NewMap(JS_PROXY_TYPE, JSProxy::kSize);
2013   Map::SetPrototype(map, prototype);
2014
2015   // Allocate the proxy object.
2016   Handle<JSProxy> result = New<JSProxy>(map, NEW_SPACE);
2017   result->InitializeBody(map->instance_size(), Smi::FromInt(0));
2018   result->set_handler(*handler);
2019   result->set_hash(*undefined_value(), SKIP_WRITE_BARRIER);
2020   return result;
2021 }
2022
2023
2024 Handle<JSProxy> Factory::NewJSFunctionProxy(Handle<Object> handler,
2025                                             Handle<Object> call_trap,
2026                                             Handle<Object> construct_trap,
2027                                             Handle<Object> prototype) {
2028   // Allocate map.
2029   // TODO(rossberg): Once we optimize proxies, think about a scheme to share
2030   // maps. Will probably depend on the identity of the handler object, too.
2031   Handle<Map> map = NewMap(JS_FUNCTION_PROXY_TYPE, JSFunctionProxy::kSize);
2032   Map::SetPrototype(map, prototype);
2033
2034   // Allocate the proxy object.
2035   Handle<JSFunctionProxy> result = New<JSFunctionProxy>(map, NEW_SPACE);
2036   result->InitializeBody(map->instance_size(), Smi::FromInt(0));
2037   result->set_handler(*handler);
2038   result->set_hash(*undefined_value(), SKIP_WRITE_BARRIER);
2039   result->set_call_trap(*call_trap);
2040   result->set_construct_trap(*construct_trap);
2041   return result;
2042 }
2043
2044
2045 void Factory::ReinitializeJSProxy(Handle<JSProxy> proxy, InstanceType type,
2046                                   int size) {
2047   DCHECK(type == JS_OBJECT_TYPE || type == JS_FUNCTION_TYPE);
2048
2049   Handle<Map> proxy_map(proxy->map());
2050   Handle<Map> map = Map::FixProxy(proxy_map, type, size);
2051
2052   // Check that the receiver has at least the size of the fresh object.
2053   int size_difference = proxy_map->instance_size() - map->instance_size();
2054   DCHECK(size_difference >= 0);
2055
2056   // Allocate the backing storage for the properties.
2057   Handle<FixedArray> properties = empty_fixed_array();
2058
2059   Heap* heap = isolate()->heap();
2060   MaybeHandle<SharedFunctionInfo> shared;
2061   if (type == JS_FUNCTION_TYPE) {
2062     OneByteStringKey key(STATIC_CHAR_VECTOR("<freezing call trap>"),
2063                          heap->HashSeed());
2064     Handle<String> name = InternalizeStringWithKey(&key);
2065     shared = NewSharedFunctionInfo(name, MaybeHandle<Code>());
2066   }
2067
2068   // In order to keep heap in consistent state there must be no allocations
2069   // before object re-initialization is finished and filler object is installed.
2070   DisallowHeapAllocation no_allocation;
2071
2072   // Put in filler if the new object is smaller than the old.
2073   if (size_difference > 0) {
2074     Address address = proxy->address();
2075     heap->CreateFillerObjectAt(address + map->instance_size(), size_difference);
2076     heap->AdjustLiveBytes(*proxy, -size_difference,
2077                           Heap::CONCURRENT_TO_SWEEPER);
2078   }
2079
2080   // Reset the map for the object.
2081   proxy->synchronized_set_map(*map);
2082   Handle<JSObject> jsobj = Handle<JSObject>::cast(proxy);
2083
2084   // Reinitialize the object from the constructor map.
2085   heap->InitializeJSObjectFromMap(*jsobj, *properties, *map);
2086
2087   // The current native context is used to set up certain bits.
2088   // TODO(adamk): Using the current context seems wrong, it should be whatever
2089   // context the JSProxy originated in. But that context isn't stored anywhere.
2090   Handle<Context> context(isolate()->native_context());
2091
2092   // Functions require some minimal initialization.
2093   if (type == JS_FUNCTION_TYPE) {
2094     map->set_function_with_prototype(true);
2095     Handle<JSFunction> js_function = Handle<JSFunction>::cast(proxy);
2096     InitializeFunction(js_function, shared.ToHandleChecked(), context);
2097   } else {
2098     // Provide JSObjects with a constructor.
2099     map->SetConstructor(context->object_function());
2100   }
2101 }
2102
2103
2104 Handle<JSGlobalProxy> Factory::NewUninitializedJSGlobalProxy() {
2105   // Create an empty shell of a JSGlobalProxy that needs to be reinitialized
2106   // via ReinitializeJSGlobalProxy later.
2107   Handle<Map> map = NewMap(JS_GLOBAL_PROXY_TYPE, JSGlobalProxy::kSize);
2108   // Maintain invariant expected from any JSGlobalProxy.
2109   map->set_is_access_check_needed(true);
2110   CALL_HEAP_FUNCTION(
2111       isolate(), isolate()->heap()->AllocateJSObjectFromMap(*map, NOT_TENURED),
2112       JSGlobalProxy);
2113 }
2114
2115
2116 void Factory::ReinitializeJSGlobalProxy(Handle<JSGlobalProxy> object,
2117                                         Handle<JSFunction> constructor) {
2118   DCHECK(constructor->has_initial_map());
2119   Handle<Map> map(constructor->initial_map(), isolate());
2120
2121   // The proxy's hash should be retained across reinitialization.
2122   Handle<Object> hash(object->hash(), isolate());
2123
2124   // Check that the already allocated object has the same size and type as
2125   // objects allocated using the constructor.
2126   DCHECK(map->instance_size() == object->map()->instance_size());
2127   DCHECK(map->instance_type() == object->map()->instance_type());
2128
2129   // Allocate the backing storage for the properties.
2130   Handle<FixedArray> properties = empty_fixed_array();
2131
2132   // In order to keep heap in consistent state there must be no allocations
2133   // before object re-initialization is finished.
2134   DisallowHeapAllocation no_allocation;
2135
2136   // Reset the map for the object.
2137   object->synchronized_set_map(*map);
2138
2139   Heap* heap = isolate()->heap();
2140   // Reinitialize the object from the constructor map.
2141   heap->InitializeJSObjectFromMap(*object, *properties, *map);
2142
2143   // Restore the saved hash.
2144   object->set_hash(*hash);
2145 }
2146
2147
2148 void Factory::BecomeJSObject(Handle<JSProxy> proxy) {
2149   ReinitializeJSProxy(proxy, JS_OBJECT_TYPE, JSObject::kHeaderSize);
2150 }
2151
2152
2153 void Factory::BecomeJSFunction(Handle<JSProxy> proxy) {
2154   ReinitializeJSProxy(proxy, JS_FUNCTION_TYPE, JSFunction::kSize);
2155 }
2156
2157
2158 template Handle<TypeFeedbackVector> Factory::NewTypeFeedbackVector(
2159     const ZoneFeedbackVectorSpec* spec);
2160 template Handle<TypeFeedbackVector> Factory::NewTypeFeedbackVector(
2161     const FeedbackVectorSpec* spec);
2162
2163 template <typename Spec>
2164 Handle<TypeFeedbackVector> Factory::NewTypeFeedbackVector(const Spec* spec) {
2165   return TypeFeedbackVector::Allocate<Spec>(isolate(), spec);
2166 }
2167
2168
2169 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
2170     Handle<String> name, int number_of_literals, FunctionKind kind,
2171     Handle<Code> code, Handle<ScopeInfo> scope_info,
2172     Handle<TypeFeedbackVector> feedback_vector) {
2173   DCHECK(IsValidFunctionKind(kind));
2174   Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(name, code);
2175   shared->set_scope_info(*scope_info);
2176   shared->set_feedback_vector(*feedback_vector);
2177   shared->set_kind(kind);
2178   shared->set_num_literals(number_of_literals);
2179   if (IsGeneratorFunction(kind)) {
2180     shared->set_instance_class_name(isolate()->heap()->Generator_string());
2181     shared->DisableOptimization(kGenerator);
2182   }
2183   return shared;
2184 }
2185
2186
2187 Handle<JSMessageObject> Factory::NewJSMessageObject(
2188     MessageTemplate::Template message, Handle<Object> argument,
2189     int start_position, int end_position, Handle<Object> script,
2190     Handle<Object> stack_frames) {
2191   Handle<Map> map = message_object_map();
2192   Handle<JSMessageObject> message_obj = New<JSMessageObject>(map, NEW_SPACE);
2193   message_obj->set_properties(*empty_fixed_array(), SKIP_WRITE_BARRIER);
2194   message_obj->initialize_elements();
2195   message_obj->set_elements(*empty_fixed_array(), SKIP_WRITE_BARRIER);
2196   message_obj->set_type(message);
2197   message_obj->set_argument(*argument);
2198   message_obj->set_start_position(start_position);
2199   message_obj->set_end_position(end_position);
2200   message_obj->set_script(*script);
2201   message_obj->set_stack_frames(*stack_frames);
2202   return message_obj;
2203 }
2204
2205
2206 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
2207     Handle<String> name,
2208     MaybeHandle<Code> maybe_code) {
2209   Handle<Map> map = shared_function_info_map();
2210   Handle<SharedFunctionInfo> share = New<SharedFunctionInfo>(map, OLD_SPACE);
2211
2212   // Set pointer fields.
2213   share->set_name(*name);
2214   Handle<Code> code;
2215   if (!maybe_code.ToHandle(&code)) {
2216     code = handle(isolate()->builtins()->builtin(Builtins::kIllegal));
2217   }
2218   share->set_code(*code);
2219   share->set_optimized_code_map(Smi::FromInt(0));
2220   share->set_scope_info(ScopeInfo::Empty(isolate()));
2221   Code* construct_stub =
2222       isolate()->builtins()->builtin(Builtins::kJSConstructStubGeneric);
2223   share->set_construct_stub(construct_stub);
2224   share->set_instance_class_name(*Object_string());
2225   share->set_function_data(*undefined_value(), SKIP_WRITE_BARRIER);
2226   share->set_script(*undefined_value(), SKIP_WRITE_BARRIER);
2227   share->set_debug_info(*undefined_value(), SKIP_WRITE_BARRIER);
2228   share->set_inferred_name(*empty_string(), SKIP_WRITE_BARRIER);
2229   FeedbackVectorSpec empty_spec(0);
2230   Handle<TypeFeedbackVector> feedback_vector =
2231       NewTypeFeedbackVector(&empty_spec);
2232   share->set_feedback_vector(*feedback_vector, SKIP_WRITE_BARRIER);
2233 #if TRACE_MAPS
2234   share->set_unique_id(isolate()->GetNextUniqueSharedFunctionInfoId());
2235 #endif
2236   share->set_profiler_ticks(0);
2237   share->set_ast_node_count(0);
2238   share->set_counters(0);
2239
2240   // Set integer fields (smi or int, depending on the architecture).
2241   share->set_length(0);
2242   share->set_internal_formal_parameter_count(0);
2243   share->set_expected_nof_properties(0);
2244   share->set_num_literals(0);
2245   share->set_start_position_and_type(0);
2246   share->set_end_position(0);
2247   share->set_function_token_position(0);
2248   // All compiler hints default to false or 0.
2249   share->set_compiler_hints(0);
2250   share->set_opt_count_and_bailout_reason(0);
2251
2252   return share;
2253 }
2254
2255
2256 static inline int NumberCacheHash(Handle<FixedArray> cache,
2257                                   Handle<Object> number) {
2258   int mask = (cache->length() >> 1) - 1;
2259   if (number->IsSmi()) {
2260     return Handle<Smi>::cast(number)->value() & mask;
2261   } else {
2262     DoubleRepresentation rep(number->Number());
2263     return
2264         (static_cast<int>(rep.bits) ^ static_cast<int>(rep.bits >> 32)) & mask;
2265   }
2266 }
2267
2268
2269 Handle<Object> Factory::GetNumberStringCache(Handle<Object> number) {
2270   DisallowHeapAllocation no_gc;
2271   int hash = NumberCacheHash(number_string_cache(), number);
2272   Object* key = number_string_cache()->get(hash * 2);
2273   if (key == *number || (key->IsHeapNumber() && number->IsHeapNumber() &&
2274                          key->Number() == number->Number())) {
2275     return Handle<String>(
2276         String::cast(number_string_cache()->get(hash * 2 + 1)), isolate());
2277   }
2278   return undefined_value();
2279 }
2280
2281
2282 void Factory::SetNumberStringCache(Handle<Object> number,
2283                                    Handle<String> string) {
2284   int hash = NumberCacheHash(number_string_cache(), number);
2285   if (number_string_cache()->get(hash * 2) != *undefined_value()) {
2286     int full_size = isolate()->heap()->FullSizeNumberStringCacheLength();
2287     if (number_string_cache()->length() != full_size) {
2288       Handle<FixedArray> new_cache = NewFixedArray(full_size, TENURED);
2289       isolate()->heap()->set_number_string_cache(*new_cache);
2290       return;
2291     }
2292   }
2293   number_string_cache()->set(hash * 2, *number);
2294   number_string_cache()->set(hash * 2 + 1, *string);
2295 }
2296
2297
2298 Handle<String> Factory::NumberToString(Handle<Object> number,
2299                                        bool check_number_string_cache) {
2300   isolate()->counters()->number_to_string_runtime()->Increment();
2301   if (check_number_string_cache) {
2302     Handle<Object> cached = GetNumberStringCache(number);
2303     if (!cached->IsUndefined()) return Handle<String>::cast(cached);
2304   }
2305
2306   char arr[100];
2307   Vector<char> buffer(arr, arraysize(arr));
2308   const char* str;
2309   if (number->IsSmi()) {
2310     int num = Handle<Smi>::cast(number)->value();
2311     str = IntToCString(num, buffer);
2312   } else {
2313     double num = Handle<HeapNumber>::cast(number)->value();
2314     str = DoubleToCString(num, buffer);
2315   }
2316
2317   // We tenure the allocated string since it is referenced from the
2318   // number-string cache which lives in the old space.
2319   Handle<String> js_string = NewStringFromAsciiChecked(str, TENURED);
2320   SetNumberStringCache(number, js_string);
2321   return js_string;
2322 }
2323
2324
2325 Handle<DebugInfo> Factory::NewDebugInfo(Handle<SharedFunctionInfo> shared) {
2326   // Allocate initial fixed array for active break points before allocating the
2327   // debug info object to avoid allocation while setting up the debug info
2328   // object.
2329   Handle<FixedArray> break_points(
2330       NewFixedArray(DebugInfo::kEstimatedNofBreakPointsInFunction));
2331
2332   // Create and set up the debug info object. Debug info contains function, a
2333   // copy of the original code, the executing code and initial fixed array for
2334   // active break points.
2335   Handle<DebugInfo> debug_info =
2336       Handle<DebugInfo>::cast(NewStruct(DEBUG_INFO_TYPE));
2337   debug_info->set_shared(*shared);
2338   debug_info->set_code(shared->code());
2339   debug_info->set_break_points(*break_points);
2340
2341   // Link debug info to function.
2342   shared->set_debug_info(*debug_info);
2343
2344   return debug_info;
2345 }
2346
2347
2348 Handle<JSObject> Factory::NewArgumentsObject(Handle<JSFunction> callee,
2349                                              int length) {
2350   bool strict_mode_callee = is_strict(callee->shared()->language_mode()) ||
2351                             !callee->has_simple_parameters();
2352   Handle<Map> map = strict_mode_callee ? isolate()->strict_arguments_map()
2353                                        : isolate()->sloppy_arguments_map();
2354   AllocationSiteUsageContext context(isolate(), Handle<AllocationSite>(),
2355                                      false);
2356   DCHECK(!isolate()->has_pending_exception());
2357   Handle<JSObject> result = NewJSObjectFromMap(map);
2358   Handle<Smi> value(Smi::FromInt(length), isolate());
2359   Object::SetProperty(result, length_string(), value, STRICT).Assert();
2360   if (!strict_mode_callee) {
2361     Object::SetProperty(result, callee_string(), callee, STRICT).Assert();
2362   }
2363   return result;
2364 }
2365
2366
2367 Handle<JSWeakMap> Factory::NewJSWeakMap() {
2368   // TODO(adamk): Currently the map is only created three times per
2369   // isolate. If it's created more often, the map should be moved into the
2370   // strong root list.
2371   Handle<Map> map = NewMap(JS_WEAK_MAP_TYPE, JSWeakMap::kSize);
2372   return Handle<JSWeakMap>::cast(NewJSObjectFromMap(map));
2373 }
2374
2375
2376 Handle<Map> Factory::ObjectLiteralMapFromCache(Handle<Context> context,
2377                                                int number_of_properties,
2378                                                bool is_strong,
2379                                                bool* is_result_from_cache) {
2380   const int kMapCacheSize = 128;
2381
2382   // We do not cache maps for too many properties or when running builtin code.
2383   if (number_of_properties > kMapCacheSize ||
2384       isolate()->bootstrapper()->IsActive()) {
2385     *is_result_from_cache = false;
2386     Handle<Map> map = Map::Create(isolate(), number_of_properties);
2387     if (is_strong) map->set_is_strong();
2388     return map;
2389   }
2390   *is_result_from_cache = true;
2391   if (number_of_properties == 0) {
2392     // Reuse the initial map of the Object function if the literal has no
2393     // predeclared properties, or the strong map if strong.
2394     return handle(is_strong
2395                       ? context->js_object_strong_map()
2396                       : context->object_function()->initial_map(), isolate());
2397   }
2398
2399   int cache_index = number_of_properties - 1;
2400   Handle<Object> maybe_cache(is_strong ? context->strong_map_cache()
2401                                        : context->map_cache(), isolate());
2402   if (maybe_cache->IsUndefined()) {
2403     // Allocate the new map cache for the native context.
2404     maybe_cache = NewFixedArray(kMapCacheSize, TENURED);
2405     if (is_strong) {
2406       context->set_strong_map_cache(*maybe_cache);
2407     } else {
2408       context->set_map_cache(*maybe_cache);
2409     }
2410   } else {
2411     // Check to see whether there is a matching element in the cache.
2412     Handle<FixedArray> cache = Handle<FixedArray>::cast(maybe_cache);
2413     Object* result = cache->get(cache_index);
2414     if (result->IsWeakCell()) {
2415       WeakCell* cell = WeakCell::cast(result);
2416       if (!cell->cleared()) {
2417         return handle(Map::cast(cell->value()), isolate());
2418       }
2419     }
2420   }
2421   // Create a new map and add it to the cache.
2422   Handle<FixedArray> cache = Handle<FixedArray>::cast(maybe_cache);
2423   Handle<Map> map = Map::Create(isolate(), number_of_properties);
2424   if (is_strong) map->set_is_strong();
2425   Handle<WeakCell> cell = NewWeakCell(map);
2426   cache->set(cache_index, *cell);
2427   return map;
2428 }
2429
2430
2431 void Factory::SetRegExpAtomData(Handle<JSRegExp> regexp,
2432                                 JSRegExp::Type type,
2433                                 Handle<String> source,
2434                                 JSRegExp::Flags flags,
2435                                 Handle<Object> data) {
2436   Handle<FixedArray> store = NewFixedArray(JSRegExp::kAtomDataSize);
2437
2438   store->set(JSRegExp::kTagIndex, Smi::FromInt(type));
2439   store->set(JSRegExp::kSourceIndex, *source);
2440   store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value()));
2441   store->set(JSRegExp::kAtomPatternIndex, *data);
2442   regexp->set_data(*store);
2443 }
2444
2445
2446 void Factory::SetRegExpIrregexpData(Handle<JSRegExp> regexp,
2447                                     JSRegExp::Type type,
2448                                     Handle<String> source,
2449                                     JSRegExp::Flags flags,
2450                                     int capture_count) {
2451   Handle<FixedArray> store = NewFixedArray(JSRegExp::kIrregexpDataSize);
2452   Smi* uninitialized = Smi::FromInt(JSRegExp::kUninitializedValue);
2453   store->set(JSRegExp::kTagIndex, Smi::FromInt(type));
2454   store->set(JSRegExp::kSourceIndex, *source);
2455   store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value()));
2456   store->set(JSRegExp::kIrregexpLatin1CodeIndex, uninitialized);
2457   store->set(JSRegExp::kIrregexpUC16CodeIndex, uninitialized);
2458   store->set(JSRegExp::kIrregexpLatin1CodeSavedIndex, uninitialized);
2459   store->set(JSRegExp::kIrregexpUC16CodeSavedIndex, uninitialized);
2460   store->set(JSRegExp::kIrregexpMaxRegisterCountIndex, Smi::FromInt(0));
2461   store->set(JSRegExp::kIrregexpCaptureCountIndex,
2462              Smi::FromInt(capture_count));
2463   regexp->set_data(*store);
2464 }
2465
2466
2467 Handle<Object> Factory::GlobalConstantFor(Handle<Name> name) {
2468   if (Name::Equals(name, undefined_string())) return undefined_value();
2469   if (Name::Equals(name, nan_string())) return nan_value();
2470   if (Name::Equals(name, infinity_string())) return infinity_value();
2471   return Handle<Object>::null();
2472 }
2473
2474
2475 Handle<Object> Factory::ToBoolean(bool value) {
2476   return value ? true_value() : false_value();
2477 }
2478
2479
2480 }  // namespace internal
2481 }  // namespace v8