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_validity_cell(Smi::FromInt(0));
  59   result->set_constructor_name(Smi::FromInt(0));
  60   return result;
  61 }
  62
  63
  64 Handle<Oddball> Factory::NewOddball(Handle<Map> map,
  65                                     const char* to_string,
  66                                     Handle<Object> to_number,
  67                                     byte kind) {
  68   Handle<Oddball> oddball = New<Oddball>(map, OLD_SPACE);
  69   Oddball::Initialize(isolate(), oddball, to_string, to_number, 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::CopyFixedArray(Handle<FixedArray> array) {
 982   CALL_HEAP_FUNCTION(isolate(),
 983                      isolate()->heap()->CopyFixedArray(*array),
 984                      FixedArray);
 985 }
 986
 987
 988 Handle<FixedArray> Factory::CopyAndTenureFixedCOWArray(
 989     Handle<FixedArray> array) {
 990   DCHECK(isolate()->heap()->InNewSpace(*array));
 991   CALL_HEAP_FUNCTION(isolate(),
 992                      isolate()->heap()->CopyAndTenureFixedCOWArray(*array),
 993                      FixedArray);
 994 }
 995
 996
 997 Handle<FixedDoubleArray> Factory::CopyFixedDoubleArray(
 998     Handle<FixedDoubleArray> array) {
 999   CALL_HEAP_FUNCTION(isolate(),
1000                      isolate()->heap()->CopyFixedDoubleArray(*array),
1001                      FixedDoubleArray);
1002 }
1003
1004
1005 Handle<Object> Factory::NewNumber(double value,
1006                                   PretenureFlag pretenure) {
1007   // We need to distinguish the minus zero value and this cannot be
1008   // done after conversion to int. Doing this by comparing bit
1009   // patterns is faster than using fpclassify() et al.
1010   if (IsMinusZero(value)) return NewHeapNumber(-0.0, IMMUTABLE, pretenure);
1011
1012   int int_value = FastD2IChecked(value);
1013   if (value == int_value && Smi::IsValid(int_value)) {
1014     return handle(Smi::FromInt(int_value), isolate());
1015   }
1016
1017   // Materialize the value in the heap.
1018   return NewHeapNumber(value, IMMUTABLE, pretenure);
1019 }
1020
1021
1022 Handle<Object> Factory::NewNumberFromInt(int32_t value,
1023                                          PretenureFlag pretenure) {
1024   if (Smi::IsValid(value)) return handle(Smi::FromInt(value), isolate());
1025   // Bypass NewNumber to avoid various redundant checks.
1026   return NewHeapNumber(FastI2D(value), IMMUTABLE, pretenure);
1027 }
1028
1029
1030 Handle<Object> Factory::NewNumberFromUint(uint32_t value,
1031                                           PretenureFlag pretenure) {
1032   int32_t int32v = static_cast<int32_t>(value);
1033   if (int32v >= 0 && Smi::IsValid(int32v)) {
1034     return handle(Smi::FromInt(int32v), isolate());
1035   }
1036   return NewHeapNumber(FastUI2D(value), IMMUTABLE, pretenure);
1037 }
1038
1039
1040 Handle<HeapNumber> Factory::NewHeapNumber(double value,
1041                                           MutableMode mode,
1042                                           PretenureFlag pretenure) {
1043   CALL_HEAP_FUNCTION(
1044       isolate(),
1045       isolate()->heap()->AllocateHeapNumber(value, mode, pretenure),
1046       HeapNumber);
1047 }
1048
1049
1050 Handle<Float32x4> Factory::NewFloat32x4(float w, float x, float y, float z,
1051                                         PretenureFlag pretenure) {
1052   CALL_HEAP_FUNCTION(
1053       isolate(), isolate()->heap()->AllocateFloat32x4(w, x, y, z, pretenure),
1054       Float32x4);
1055 }
1056
1057
1058 Handle<Object> Factory::NewError(const char* maker,
1059                                  MessageTemplate::Template template_index,
1060                                  Handle<Object> arg0, Handle<Object> arg1,
1061                                  Handle<Object> arg2) {
1062   HandleScope scope(isolate());
1063   Handle<String> error_maker = InternalizeUtf8String(maker);
1064   if (isolate()->bootstrapper()->IsActive()) {
1065     // If this exception is being thrown during bootstrapping,
1066     // js_builtins_object is unavailable. We return the error maker
1067     // name's string as the exception since we have nothing better
1068     // to do.
1069     return scope.CloseAndEscape(error_maker);
1070   }
1071   Handle<Object> fun_obj = Object::GetProperty(isolate()->js_builtins_object(),
1072                                                error_maker).ToHandleChecked();
1073
1074   Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
1075   Handle<Object> message_type(Smi::FromInt(template_index), isolate());
1076   if (arg0.is_null()) arg0 = undefined_value();
1077   if (arg1.is_null()) arg1 = undefined_value();
1078   if (arg2.is_null()) arg2 = undefined_value();
1079   Handle<Object> argv[] = {message_type, arg0, arg1, arg2};
1080
1081   // Invoke the JavaScript factory method. If an exception is thrown while
1082   // running the factory method, use the exception as the result.
1083   Handle<Object> result;
1084   MaybeHandle<Object> exception;
1085   if (!Execution::TryCall(fun, isolate()->js_builtins_object(), arraysize(argv),
1086                           argv, &exception).ToHandle(&result)) {
1087     Handle<Object> exception_obj;
1088     if (exception.ToHandle(&exception_obj)) {
1089       result = exception_obj;
1090     } else {
1091       result = undefined_value();
1092     }
1093   }
1094   return scope.CloseAndEscape(result);
1095 }
1096
1097
1098 Handle<Object> Factory::NewError(MessageTemplate::Template template_index,
1099                                  Handle<Object> arg0, Handle<Object> arg1,
1100                                  Handle<Object> arg2) {
1101   return NewError("MakeError", template_index, arg0, arg1, arg2);
1102 }
1103
1104
1105 Handle<Object> Factory::NewTypeError(MessageTemplate::Template template_index,
1106                                      Handle<Object> arg0, Handle<Object> arg1,
1107                                      Handle<Object> arg2) {
1108   return NewError("MakeTypeError", template_index, arg0, arg1, arg2);
1109 }
1110
1111
1112 Handle<Object> Factory::NewSyntaxError(MessageTemplate::Template template_index,
1113                                        Handle<Object> arg0, Handle<Object> arg1,
1114                                        Handle<Object> arg2) {
1115   return NewError("MakeSyntaxError", template_index, arg0, arg1, arg2);
1116 }
1117
1118
1119 Handle<Object> Factory::NewReferenceError(
1120     MessageTemplate::Template template_index, Handle<Object> arg0,
1121     Handle<Object> arg1, Handle<Object> arg2) {
1122   return NewError("MakeReferenceError", template_index, arg0, arg1, arg2);
1123 }
1124
1125
1126 Handle<Object> Factory::NewRangeError(MessageTemplate::Template template_index,
1127                                       Handle<Object> arg0, Handle<Object> arg1,
1128                                       Handle<Object> arg2) {
1129   return NewError("MakeRangeError", template_index, arg0, arg1, arg2);
1130 }
1131
1132
1133 Handle<Object> Factory::NewEvalError(MessageTemplate::Template template_index,
1134                                      Handle<Object> arg0, Handle<Object> arg1,
1135                                      Handle<Object> arg2) {
1136   return NewError("MakeEvalError", template_index, arg0, arg1, arg2);
1137 }
1138
1139
1140 Handle<String> Factory::EmergencyNewError(const char* message,
1141                                           Handle<JSArray> args) {
1142   const int kBufferSize = 1000;
1143   char buffer[kBufferSize];
1144   size_t space = kBufferSize;
1145   char* p = &buffer[0];
1146
1147   Vector<char> v(buffer, kBufferSize);
1148   StrNCpy(v, message, space);
1149   space -= Min(space, strlen(message));
1150   p = &buffer[kBufferSize] - space;
1151
1152   for (int i = 0; i < Smi::cast(args->length())->value(); i++) {
1153     if (space > 0) {
1154       *p++ = ' ';
1155       space--;
1156       if (space > 0) {
1157         Handle<String> arg_str = Handle<String>::cast(
1158             Object::GetElement(isolate(), args, i).ToHandleChecked());
1159         base::SmartArrayPointer<char> arg = arg_str->ToCString();
1160         Vector<char> v2(p, static_cast<int>(space));
1161         StrNCpy(v2, arg.get(), space);
1162         space -= Min(space, strlen(arg.get()));
1163         p = &buffer[kBufferSize] - space;
1164       }
1165     }
1166   }
1167   if (space > 0) {
1168     *p = '\0';
1169   } else {
1170     buffer[kBufferSize - 1] = '\0';
1171   }
1172   return NewStringFromUtf8(CStrVector(buffer), TENURED).ToHandleChecked();
1173 }
1174
1175
1176 Handle<Object> Factory::NewError(const char* maker, const char* message,
1177                                  Handle<JSArray> args) {
1178   Handle<String> make_str = InternalizeUtf8String(maker);
1179   Handle<Object> fun_obj = Object::GetProperty(
1180       isolate()->js_builtins_object(), make_str).ToHandleChecked();
1181   // If the builtins haven't been properly configured yet this error
1182   // constructor may not have been defined.  Bail out.
1183   if (!fun_obj->IsJSFunction()) {
1184     return EmergencyNewError(message, args);
1185   }
1186   Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
1187   Handle<Object> message_obj = InternalizeUtf8String(message);
1188   Handle<Object> argv[] = { message_obj, args };
1189
1190   // Invoke the JavaScript factory method. If an exception is thrown while
1191   // running the factory method, use the exception as the result.
1192   Handle<Object> result;
1193   MaybeHandle<Object> exception;
1194   if (!Execution::TryCall(fun,
1195                           isolate()->js_builtins_object(),
1196                           arraysize(argv),
1197                           argv,
1198                           &exception).ToHandle(&result)) {
1199     Handle<Object> exception_obj;
1200     if (exception.ToHandle(&exception_obj)) return exception_obj;
1201     return undefined_value();
1202   }
1203   return result;
1204 }
1205
1206
1207 Handle<Object> Factory::NewError(const char* constructor,
1208                                  Handle<String> message) {
1209   Handle<String> constr = InternalizeUtf8String(constructor);
1210   Handle<JSFunction> fun = Handle<JSFunction>::cast(Object::GetProperty(
1211       isolate()->js_builtins_object(), constr).ToHandleChecked());
1212   Handle<Object> argv[] = { message };
1213
1214   // Invoke the JavaScript factory method. If an exception is thrown while
1215   // running the factory method, use the exception as the result.
1216   Handle<Object> result;
1217   MaybeHandle<Object> exception;
1218   if (!Execution::TryCall(fun,
1219                           isolate()->js_builtins_object(),
1220                           arraysize(argv),
1221                           argv,
1222                           &exception).ToHandle(&result)) {
1223     Handle<Object> exception_obj;
1224     if (exception.ToHandle(&exception_obj)) return exception_obj;
1225     return undefined_value();
1226   }
1227   return result;
1228 }
1229
1230
1231 void Factory::InitializeFunction(Handle<JSFunction> function,
1232                                  Handle<SharedFunctionInfo> info,
1233                                  Handle<Context> context) {
1234   function->initialize_properties();
1235   function->initialize_elements();
1236   function->set_shared(*info);
1237   function->set_code(info->code());
1238   function->set_context(*context);
1239   function->set_prototype_or_initial_map(*the_hole_value());
1240   function->set_literals_or_bindings(*empty_fixed_array());
1241   function->set_next_function_link(*undefined_value(), SKIP_WRITE_BARRIER);
1242 }
1243
1244
1245 Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
1246                                         Handle<SharedFunctionInfo> info,
1247                                         Handle<Context> context,
1248                                         PretenureFlag pretenure) {
1249   AllocationSpace space = pretenure == TENURED ? OLD_SPACE : NEW_SPACE;
1250   Handle<JSFunction> result = New<JSFunction>(map, space);
1251   InitializeFunction(result, info, context);
1252   return result;
1253 }
1254
1255
1256 Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
1257                                         Handle<String> name,
1258                                         MaybeHandle<Code> code) {
1259   Handle<Context> context(isolate()->native_context());
1260   Handle<SharedFunctionInfo> info = NewSharedFunctionInfo(name, code);
1261   DCHECK(is_sloppy(info->language_mode()) &&
1262          (map.is_identical_to(isolate()->sloppy_function_map()) ||
1263           map.is_identical_to(
1264               isolate()->sloppy_function_without_prototype_map()) ||
1265           map.is_identical_to(
1266               isolate()->sloppy_function_with_readonly_prototype_map()) ||
1267           map.is_identical_to(isolate()->strict_function_map())));
1268   return NewFunction(map, info, context);
1269 }
1270
1271
1272 Handle<JSFunction> Factory::NewFunction(Handle<String> name) {
1273   return NewFunction(
1274       isolate()->sloppy_function_map(), name, MaybeHandle<Code>());
1275 }
1276
1277
1278 Handle<JSFunction> Factory::NewFunctionWithoutPrototype(Handle<String> name,
1279                                                         Handle<Code> code,
1280                                                         bool is_strict) {
1281   Handle<Map> map = is_strict
1282                         ? isolate()->strict_function_without_prototype_map()
1283                         : isolate()->sloppy_function_without_prototype_map();
1284   return NewFunction(map, name, code);
1285 }
1286
1287
1288 Handle<JSFunction> Factory::NewFunction(Handle<String> name, Handle<Code> code,
1289                                         Handle<Object> prototype,
1290                                         bool read_only_prototype,
1291                                         bool is_strict) {
1292   // In strict mode, readonly strict map is only available during bootstrap
1293   DCHECK(!is_strict || !read_only_prototype ||
1294          isolate()->bootstrapper()->IsActive());
1295   Handle<Map> map =
1296       is_strict ? isolate()->strict_function_map()
1297                 : read_only_prototype
1298                       ? isolate()->sloppy_function_with_readonly_prototype_map()
1299                       : isolate()->sloppy_function_map();
1300   Handle<JSFunction> result = NewFunction(map, name, code);
1301   result->set_prototype_or_initial_map(*prototype);
1302   return result;
1303 }
1304
1305
1306 Handle<JSFunction> Factory::NewFunction(Handle<String> name, Handle<Code> code,
1307                                         Handle<Object> prototype,
1308                                         InstanceType type, int instance_size,
1309                                         bool read_only_prototype,
1310                                         bool install_constructor,
1311                                         bool is_strict) {
1312   // Allocate the function
1313   Handle<JSFunction> function =
1314       NewFunction(name, code, prototype, read_only_prototype, is_strict);
1315
1316   ElementsKind elements_kind =
1317       type == JS_ARRAY_TYPE ? FAST_SMI_ELEMENTS : FAST_HOLEY_SMI_ELEMENTS;
1318   Handle<Map> initial_map = NewMap(type, instance_size, elements_kind);
1319   if (!function->shared()->is_generator()) {
1320     if (prototype->IsTheHole()) {
1321       prototype = NewFunctionPrototype(function);
1322     } else if (install_constructor) {
1323       JSObject::AddProperty(Handle<JSObject>::cast(prototype),
1324                             constructor_string(), function, DONT_ENUM);
1325     }
1326   }
1327
1328   JSFunction::SetInitialMap(function, initial_map,
1329                             Handle<JSReceiver>::cast(prototype));
1330
1331   return function;
1332 }
1333
1334
1335 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
1336                                         Handle<Code> code,
1337                                         InstanceType type,
1338                                         int instance_size) {
1339   return NewFunction(name, code, the_hole_value(), type, instance_size);
1340 }
1341
1342
1343 Handle<JSObject> Factory::NewFunctionPrototype(Handle<JSFunction> function) {
1344   // Make sure to use globals from the function's context, since the function
1345   // can be from a different context.
1346   Handle<Context> native_context(function->context()->native_context());
1347   Handle<Map> new_map;
1348   if (function->shared()->is_generator()) {
1349     // Generator prototypes can share maps since they don't have "constructor"
1350     // properties.
1351     new_map = handle(native_context->generator_object_prototype_map());
1352   } else {
1353     // Each function prototype gets a fresh map to avoid unwanted sharing of
1354     // maps between prototypes of different constructors.
1355     Handle<JSFunction> object_function(native_context->object_function());
1356     DCHECK(object_function->has_initial_map());
1357     new_map = handle(object_function->initial_map());
1358   }
1359
1360   DCHECK(!new_map->is_prototype_map());
1361   Handle<JSObject> prototype = NewJSObjectFromMap(new_map);
1362
1363   if (!function->shared()->is_generator()) {
1364     JSObject::AddProperty(prototype, constructor_string(), function, DONT_ENUM);
1365   }
1366
1367   return prototype;
1368 }
1369
1370
1371 Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
1372     Handle<SharedFunctionInfo> info,
1373     Handle<Context> context,
1374     PretenureFlag pretenure) {
1375   int map_index =
1376       Context::FunctionMapIndex(info->language_mode(), info->kind());
1377   Handle<Map> map(Map::cast(context->native_context()->get(map_index)));
1378   Handle<JSFunction> result = NewFunction(map, info, context, pretenure);
1379
1380   if (info->ic_age() != isolate()->heap()->global_ic_age()) {
1381     info->ResetForNewContext(isolate()->heap()->global_ic_age());
1382   }
1383
1384   if (FLAG_always_opt && info->allows_lazy_compilation()) {
1385     result->MarkForOptimization();
1386   }
1387
1388   CodeAndLiterals cached = info->SearchOptimizedCodeMap(
1389       context->native_context(), BailoutId::None());
1390   if (cached.code != nullptr) {
1391     // Caching of optimized code enabled and optimized code found.
1392     if (cached.literals != nullptr) result->set_literals(cached.literals);
1393     DCHECK(!cached.code->marked_for_deoptimization());
1394     DCHECK(result->shared()->is_compiled());
1395     result->ReplaceCode(cached.code);
1396   }
1397
1398   if (cached.literals == nullptr && !info->bound()) {
1399     int number_of_literals = info->num_literals();
1400     // TODO(mstarzinger): Consider sharing the newly created literals array.
1401     Handle<FixedArray> literals = NewFixedArray(number_of_literals, pretenure);
1402     result->set_literals(*literals);
1403   }
1404
1405   return result;
1406 }
1407
1408
1409 Handle<ScopeInfo> Factory::NewScopeInfo(int length) {
1410   Handle<FixedArray> array = NewFixedArray(length, TENURED);
1411   array->set_map_no_write_barrier(*scope_info_map());
1412   Handle<ScopeInfo> scope_info = Handle<ScopeInfo>::cast(array);
1413   return scope_info;
1414 }
1415
1416
1417 Handle<JSObject> Factory::NewExternal(void* value) {
1418   Handle<Foreign> foreign = NewForeign(static_cast<Address>(value));
1419   Handle<JSObject> external = NewJSObjectFromMap(external_map());
1420   external->SetInternalField(0, *foreign);
1421   return external;
1422 }
1423
1424
1425 Handle<Code> Factory::NewCodeRaw(int object_size, bool immovable) {
1426   CALL_HEAP_FUNCTION(isolate(),
1427                      isolate()->heap()->AllocateCode(object_size, immovable),
1428                      Code);
1429 }
1430
1431
1432 Handle<Code> Factory::NewCode(const CodeDesc& desc,
1433                               Code::Flags flags,
1434                               Handle<Object> self_ref,
1435                               bool immovable,
1436                               bool crankshafted,
1437                               int prologue_offset,
1438                               bool is_debug) {
1439   Handle<ByteArray> reloc_info = NewByteArray(desc.reloc_size, TENURED);
1440
1441   // Compute size.
1442   int body_size = RoundUp(desc.instr_size, kObjectAlignment);
1443   int obj_size = Code::SizeFor(body_size);
1444
1445   Handle<Code> code = NewCodeRaw(obj_size, immovable);
1446   DCHECK(isolate()->code_range() == NULL || !isolate()->code_range()->valid() ||
1447          isolate()->code_range()->contains(code->address()) ||
1448          obj_size <= isolate()->heap()->code_space()->AreaSize());
1449
1450   // The code object has not been fully initialized yet.  We rely on the
1451   // fact that no allocation will happen from this point on.
1452   DisallowHeapAllocation no_gc;
1453   code->set_gc_metadata(Smi::FromInt(0));
1454   code->set_ic_age(isolate()->heap()->global_ic_age());
1455   code->set_instruction_size(desc.instr_size);
1456   code->set_relocation_info(*reloc_info);
1457   code->set_flags(flags);
1458   code->set_raw_kind_specific_flags1(0);
1459   code->set_raw_kind_specific_flags2(0);
1460   code->set_is_crankshafted(crankshafted);
1461   code->set_deoptimization_data(*empty_fixed_array(), SKIP_WRITE_BARRIER);
1462   code->set_raw_type_feedback_info(Smi::FromInt(0));
1463   code->set_next_code_link(*undefined_value());
1464   code->set_handler_table(*empty_fixed_array(), SKIP_WRITE_BARRIER);
1465   code->set_prologue_offset(prologue_offset);
1466   if (FLAG_enable_embedded_constant_pool) {
1467     code->set_constant_pool_offset(desc.instr_size - desc.constant_pool_size);
1468   }
1469   if (code->kind() == Code::OPTIMIZED_FUNCTION) {
1470     code->set_marked_for_deoptimization(false);
1471   }
1472
1473   if (is_debug) {
1474     DCHECK(code->kind() == Code::FUNCTION);
1475     code->set_has_debug_break_slots(true);
1476   }
1477
1478   // Allow self references to created code object by patching the handle to
1479   // point to the newly allocated Code object.
1480   if (!self_ref.is_null()) *(self_ref.location()) = *code;
1481
1482   // Migrate generated code.
1483   // The generated code can contain Object** values (typically from handles)
1484   // that are dereferenced during the copy to point directly to the actual heap
1485   // objects. These pointers can include references to the code object itself,
1486   // through the self_reference parameter.
1487   code->CopyFrom(desc);
1488
1489 #ifdef VERIFY_HEAP
1490   if (FLAG_verify_heap) code->ObjectVerify();
1491 #endif
1492   return code;
1493 }
1494
1495
1496 Handle<Code> Factory::CopyCode(Handle<Code> code) {
1497   CALL_HEAP_FUNCTION(isolate(),
1498                      isolate()->heap()->CopyCode(*code),
1499                      Code);
1500 }
1501
1502
1503 Handle<Code> Factory::CopyCode(Handle<Code> code, Vector<byte> reloc_info) {
1504   CALL_HEAP_FUNCTION(isolate(),
1505                      isolate()->heap()->CopyCode(*code, reloc_info),
1506                      Code);
1507 }
1508
1509
1510 Handle<JSObject> Factory::NewJSObject(Handle<JSFunction> constructor,
1511                                       PretenureFlag pretenure) {
1512   JSFunction::EnsureHasInitialMap(constructor);
1513   CALL_HEAP_FUNCTION(
1514       isolate(),
1515       isolate()->heap()->AllocateJSObject(*constructor, pretenure), JSObject);
1516 }
1517
1518
1519 Handle<JSObject> Factory::NewJSObjectWithMemento(
1520     Handle<JSFunction> constructor,
1521     Handle<AllocationSite> site) {
1522   JSFunction::EnsureHasInitialMap(constructor);
1523   CALL_HEAP_FUNCTION(
1524       isolate(),
1525       isolate()->heap()->AllocateJSObject(*constructor, NOT_TENURED, *site),
1526       JSObject);
1527 }
1528
1529
1530 Handle<JSModule> Factory::NewJSModule(Handle<Context> context,
1531                                       Handle<ScopeInfo> scope_info) {
1532   // Allocate a fresh map. Modules do not have a prototype.
1533   Handle<Map> map = NewMap(JS_MODULE_TYPE, JSModule::kSize);
1534   // Allocate the object based on the map.
1535   Handle<JSModule> module =
1536       Handle<JSModule>::cast(NewJSObjectFromMap(map, TENURED));
1537   module->set_context(*context);
1538   module->set_scope_info(*scope_info);
1539   return module;
1540 }
1541
1542
1543 Handle<GlobalObject> Factory::NewGlobalObject(Handle<JSFunction> constructor) {
1544   DCHECK(constructor->has_initial_map());
1545   Handle<Map> map(constructor->initial_map());
1546   DCHECK(map->is_dictionary_map());
1547
1548   // Make sure no field properties are described in the initial map.
1549   // This guarantees us that normalizing the properties does not
1550   // require us to change property values to PropertyCells.
1551   DCHECK(map->NextFreePropertyIndex() == 0);
1552
1553   // Make sure we don't have a ton of pre-allocated slots in the
1554   // global objects. They will be unused once we normalize the object.
1555   DCHECK(map->unused_property_fields() == 0);
1556   DCHECK(map->inobject_properties() == 0);
1557
1558   // Initial size of the backing store to avoid resize of the storage during
1559   // bootstrapping. The size differs between the JS global object ad the
1560   // builtins object.
1561   int initial_size = map->instance_type() == JS_GLOBAL_OBJECT_TYPE ? 64 : 512;
1562
1563   // Allocate a dictionary object for backing storage.
1564   int at_least_space_for = map->NumberOfOwnDescriptors() * 2 + initial_size;
1565   Handle<GlobalDictionary> dictionary =
1566       GlobalDictionary::New(isolate(), at_least_space_for);
1567
1568   // The global object might be created from an object template with accessors.
1569   // Fill these accessors into the dictionary.
1570   Handle<DescriptorArray> descs(map->instance_descriptors());
1571   for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {
1572     PropertyDetails details = descs->GetDetails(i);
1573     // Only accessors are expected.
1574     DCHECK_EQ(ACCESSOR_CONSTANT, details.type());
1575     PropertyDetails d(details.attributes(), ACCESSOR_CONSTANT, i + 1,
1576                       PropertyCellType::kMutable);
1577     Handle<Name> name(descs->GetKey(i));
1578     Handle<PropertyCell> cell = NewPropertyCell();
1579     cell->set_value(descs->GetCallbacksObject(i));
1580     // |dictionary| already contains enough space for all properties.
1581     USE(GlobalDictionary::Add(dictionary, name, cell, d));
1582   }
1583
1584   // Allocate the global object and initialize it with the backing store.
1585   Handle<GlobalObject> global = New<GlobalObject>(map, OLD_SPACE);
1586   isolate()->heap()->InitializeJSObjectFromMap(*global, *dictionary, *map);
1587
1588   // Create a new map for the global object.
1589   Handle<Map> new_map = Map::CopyDropDescriptors(map);
1590   new_map->set_dictionary_map(true);
1591
1592   // Set up the global object as a normalized object.
1593   global->set_map(*new_map);
1594   global->set_properties(*dictionary);
1595
1596   // Make sure result is a global object with properties in dictionary.
1597   DCHECK(global->IsGlobalObject() && !global->HasFastProperties());
1598   return global;
1599 }
1600
1601
1602 Handle<JSObject> Factory::NewJSObjectFromMap(
1603     Handle<Map> map,
1604     PretenureFlag pretenure,
1605     Handle<AllocationSite> allocation_site) {
1606   CALL_HEAP_FUNCTION(
1607       isolate(),
1608       isolate()->heap()->AllocateJSObjectFromMap(
1609           *map,
1610           pretenure,
1611           allocation_site.is_null() ? NULL : *allocation_site),
1612       JSObject);
1613 }
1614
1615
1616 Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind,
1617                                     Strength strength,
1618                                     PretenureFlag pretenure) {
1619   Map* map = isolate()->get_initial_js_array_map(elements_kind, strength);
1620   if (map == nullptr) {
1621     DCHECK(strength == Strength::WEAK);
1622     Context* native_context = isolate()->context()->native_context();
1623     JSFunction* array_function = native_context->array_function();
1624     map = array_function->initial_map();
1625   }
1626   return Handle<JSArray>::cast(NewJSObjectFromMap(handle(map), pretenure));
1627 }
1628
1629
1630 Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind, int length,
1631                                     int capacity, Strength strength,
1632                                     ArrayStorageAllocationMode mode,
1633                                     PretenureFlag pretenure) {
1634   Handle<JSArray> array = NewJSArray(elements_kind, strength, pretenure);
1635   NewJSArrayStorage(array, length, capacity, mode);
1636   return array;
1637 }
1638
1639
1640 Handle<JSArray> Factory::NewJSArrayWithElements(Handle<FixedArrayBase> elements,
1641                                                 ElementsKind elements_kind,
1642                                                 int length, Strength strength,
1643                                                 PretenureFlag pretenure) {
1644   DCHECK(length <= elements->length());
1645   Handle<JSArray> array = NewJSArray(elements_kind, strength, pretenure);
1646
1647   array->set_elements(*elements);
1648   array->set_length(Smi::FromInt(length));
1649   JSObject::ValidateElements(array);
1650   return array;
1651 }
1652
1653
1654 void Factory::NewJSArrayStorage(Handle<JSArray> array,
1655                                 int length,
1656                                 int capacity,
1657                                 ArrayStorageAllocationMode mode) {
1658   DCHECK(capacity >= length);
1659
1660   if (capacity == 0) {
1661     array->set_length(Smi::FromInt(0));
1662     array->set_elements(*empty_fixed_array());
1663     return;
1664   }
1665
1666   HandleScope inner_scope(isolate());
1667   Handle<FixedArrayBase> elms;
1668   ElementsKind elements_kind = array->GetElementsKind();
1669   if (IsFastDoubleElementsKind(elements_kind)) {
1670     if (mode == DONT_INITIALIZE_ARRAY_ELEMENTS) {
1671       elms = NewFixedDoubleArray(capacity);
1672     } else {
1673       DCHECK(mode == INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
1674       elms = NewFixedDoubleArrayWithHoles(capacity);
1675     }
1676   } else {
1677     DCHECK(IsFastSmiOrObjectElementsKind(elements_kind));
1678     if (mode == DONT_INITIALIZE_ARRAY_ELEMENTS) {
1679       elms = NewUninitializedFixedArray(capacity);
1680     } else {
1681       DCHECK(mode == INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
1682       elms = NewFixedArrayWithHoles(capacity);
1683     }
1684   }
1685
1686   array->set_elements(*elms);
1687   array->set_length(Smi::FromInt(length));
1688 }
1689
1690
1691 Handle<JSGeneratorObject> Factory::NewJSGeneratorObject(
1692     Handle<JSFunction> function) {
1693   DCHECK(function->shared()->is_generator());
1694   JSFunction::EnsureHasInitialMap(function);
1695   Handle<Map> map(function->initial_map());
1696   DCHECK(map->instance_type() == JS_GENERATOR_OBJECT_TYPE);
1697   CALL_HEAP_FUNCTION(
1698       isolate(),
1699       isolate()->heap()->AllocateJSObjectFromMap(*map),
1700       JSGeneratorObject);
1701 }
1702
1703
1704 Handle<JSArrayBuffer> Factory::NewJSArrayBuffer(SharedFlag shared) {
1705   Handle<JSFunction> array_buffer_fun(
1706       shared == SharedFlag::kShared
1707           ? isolate()->native_context()->shared_array_buffer_fun()
1708           : isolate()->native_context()->array_buffer_fun());
1709   CALL_HEAP_FUNCTION(
1710       isolate(),
1711       isolate()->heap()->AllocateJSObject(*array_buffer_fun),
1712       JSArrayBuffer);
1713 }
1714
1715
1716 Handle<JSDataView> Factory::NewJSDataView() {
1717   Handle<JSFunction> data_view_fun(
1718       isolate()->native_context()->data_view_fun());
1719   CALL_HEAP_FUNCTION(
1720       isolate(),
1721       isolate()->heap()->AllocateJSObject(*data_view_fun),
1722       JSDataView);
1723 }
1724
1725
1726 Handle<JSMap> Factory::NewJSMap() {
1727   Handle<Map> map(isolate()->native_context()->js_map_map());
1728   Handle<JSMap> js_map = Handle<JSMap>::cast(NewJSObjectFromMap(map));
1729   Runtime::JSMapInitialize(isolate(), js_map);
1730   return js_map;
1731 }
1732
1733
1734 Handle<JSSet> Factory::NewJSSet() {
1735   Handle<Map> map(isolate()->native_context()->js_set_map());
1736   Handle<JSSet> js_set = Handle<JSSet>::cast(NewJSObjectFromMap(map));
1737   Runtime::JSSetInitialize(isolate(), js_set);
1738   return js_set;
1739 }
1740
1741
1742 Handle<JSMapIterator> Factory::NewJSMapIterator() {
1743   Handle<Map> map(isolate()->native_context()->map_iterator_map());
1744   CALL_HEAP_FUNCTION(isolate(),
1745                      isolate()->heap()->AllocateJSObjectFromMap(*map),
1746                      JSMapIterator);
1747 }
1748
1749
1750 Handle<JSSetIterator> Factory::NewJSSetIterator() {
1751   Handle<Map> map(isolate()->native_context()->set_iterator_map());
1752   CALL_HEAP_FUNCTION(isolate(),
1753                      isolate()->heap()->AllocateJSObjectFromMap(*map),
1754                      JSSetIterator);
1755 }
1756
1757
1758 namespace {
1759
1760 ElementsKind GetExternalArrayElementsKind(ExternalArrayType type) {
1761   switch (type) {
1762 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
1763   case kExternal##Type##Array:                          \
1764     return TYPE##_ELEMENTS;
1765     TYPED_ARRAYS(TYPED_ARRAY_CASE)
1766   }
1767   UNREACHABLE();
1768   return FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND;
1769 #undef TYPED_ARRAY_CASE
1770 }
1771
1772
1773 size_t GetExternalArrayElementSize(ExternalArrayType type) {
1774   switch (type) {
1775 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
1776   case kExternal##Type##Array:                          \
1777     return size;
1778     TYPED_ARRAYS(TYPED_ARRAY_CASE)
1779     default:
1780       UNREACHABLE();
1781       return 0;
1782   }
1783 #undef TYPED_ARRAY_CASE
1784 }
1785
1786
1787 size_t GetFixedTypedArraysElementSize(ElementsKind kind) {
1788   switch (kind) {
1789 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
1790   case TYPE##_ELEMENTS:                                 \
1791     return size;
1792     TYPED_ARRAYS(TYPED_ARRAY_CASE)
1793     default:
1794       UNREACHABLE();
1795       return 0;
1796   }
1797 #undef TYPED_ARRAY_CASE
1798 }
1799
1800
1801 ExternalArrayType GetArrayTypeFromElementsKind(ElementsKind kind) {
1802   switch (kind) {
1803 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
1804   case TYPE##_ELEMENTS:                                 \
1805     return kExternal##Type##Array;
1806     TYPED_ARRAYS(TYPED_ARRAY_CASE)
1807     default:
1808       UNREACHABLE();
1809       return kExternalInt8Array;
1810   }
1811 #undef TYPED_ARRAY_CASE
1812 }
1813
1814
1815 JSFunction* GetTypedArrayFun(ExternalArrayType type, Isolate* isolate) {
1816   Context* native_context = isolate->context()->native_context();
1817   switch (type) {
1818 #define TYPED_ARRAY_FUN(Type, type, TYPE, ctype, size)                        \
1819     case kExternal##Type##Array:                                              \
1820       return native_context->type##_array_fun();
1821
1822     TYPED_ARRAYS(TYPED_ARRAY_FUN)
1823 #undef TYPED_ARRAY_FUN
1824
1825     default:
1826       UNREACHABLE();
1827       return NULL;
1828   }
1829 }
1830
1831
1832 JSFunction* GetTypedArrayFun(ElementsKind elements_kind, Isolate* isolate) {
1833   Context* native_context = isolate->context()->native_context();
1834   switch (elements_kind) {
1835 #define TYPED_ARRAY_FUN(Type, type, TYPE, ctype, size) \
1836   case TYPE##_ELEMENTS:                                \
1837     return native_context->type##_array_fun();
1838
1839     TYPED_ARRAYS(TYPED_ARRAY_FUN)
1840 #undef TYPED_ARRAY_FUN
1841
1842     default:
1843       UNREACHABLE();
1844       return NULL;
1845   }
1846 }
1847
1848
1849 void SetupArrayBufferView(i::Isolate* isolate,
1850                           i::Handle<i::JSArrayBufferView> obj,
1851                           i::Handle<i::JSArrayBuffer> buffer,
1852                           size_t byte_offset, size_t byte_length) {
1853   DCHECK(byte_offset + byte_length <=
1854          static_cast<size_t>(buffer->byte_length()->Number()));
1855
1856   obj->set_buffer(*buffer);
1857
1858   i::Handle<i::Object> byte_offset_object =
1859       isolate->factory()->NewNumberFromSize(byte_offset);
1860   obj->set_byte_offset(*byte_offset_object);
1861
1862   i::Handle<i::Object> byte_length_object =
1863       isolate->factory()->NewNumberFromSize(byte_length);
1864   obj->set_byte_length(*byte_length_object);
1865 }
1866
1867
1868 }  // namespace
1869
1870
1871 Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type) {
1872   Handle<JSFunction> typed_array_fun_handle(GetTypedArrayFun(type, isolate()));
1873
1874   CALL_HEAP_FUNCTION(
1875       isolate(),
1876       isolate()->heap()->AllocateJSObject(*typed_array_fun_handle),
1877       JSTypedArray);
1878 }
1879
1880
1881 Handle<JSTypedArray> Factory::NewJSTypedArray(ElementsKind elements_kind) {
1882   Handle<JSFunction> typed_array_fun_handle(
1883       GetTypedArrayFun(elements_kind, isolate()));
1884
1885   CALL_HEAP_FUNCTION(
1886       isolate(), isolate()->heap()->AllocateJSObject(*typed_array_fun_handle),
1887       JSTypedArray);
1888 }
1889
1890
1891 Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type,
1892                                               Handle<JSArrayBuffer> buffer,
1893                                               size_t byte_offset,
1894                                               size_t length) {
1895   Handle<JSTypedArray> obj = NewJSTypedArray(type);
1896
1897   size_t element_size = GetExternalArrayElementSize(type);
1898   ElementsKind elements_kind = GetExternalArrayElementsKind(type);
1899
1900   CHECK(byte_offset % element_size == 0);
1901
1902   CHECK(length <= (std::numeric_limits<size_t>::max() / element_size));
1903   CHECK(length <= static_cast<size_t>(Smi::kMaxValue));
1904   size_t byte_length = length * element_size;
1905   SetupArrayBufferView(isolate(), obj, buffer, byte_offset, byte_length);
1906
1907   Handle<Object> length_object = NewNumberFromSize(length);
1908   obj->set_length(*length_object);
1909
1910   Handle<FixedTypedArrayBase> elements = NewFixedTypedArrayWithExternalPointer(
1911       static_cast<int>(length), type,
1912       static_cast<uint8_t*>(buffer->backing_store()) + byte_offset);
1913   Handle<Map> map = JSObject::GetElementsTransitionMap(obj, elements_kind);
1914   JSObject::SetMapAndElements(obj, map, elements);
1915   return obj;
1916 }
1917
1918
1919 Handle<JSTypedArray> Factory::NewJSTypedArray(ElementsKind elements_kind,
1920                                               size_t number_of_elements) {
1921   Handle<JSTypedArray> obj = NewJSTypedArray(elements_kind);
1922
1923   size_t element_size = GetFixedTypedArraysElementSize(elements_kind);
1924   ExternalArrayType array_type = GetArrayTypeFromElementsKind(elements_kind);
1925
1926   CHECK(number_of_elements <=
1927         (std::numeric_limits<size_t>::max() / element_size));
1928   CHECK(number_of_elements <= static_cast<size_t>(Smi::kMaxValue));
1929   size_t byte_length = number_of_elements * element_size;
1930
1931   obj->set_byte_offset(Smi::FromInt(0));
1932   i::Handle<i::Object> byte_length_object =
1933       isolate()->factory()->NewNumberFromSize(byte_length);
1934   obj->set_byte_length(*byte_length_object);
1935   Handle<Object> length_object = NewNumberFromSize(number_of_elements);
1936   obj->set_length(*length_object);
1937
1938   Handle<JSArrayBuffer> buffer = isolate()->factory()->NewJSArrayBuffer();
1939   Runtime::SetupArrayBuffer(isolate(), buffer, true, NULL, byte_length,
1940                             SharedFlag::kNotShared);
1941   obj->set_buffer(*buffer);
1942   Handle<FixedTypedArrayBase> elements =
1943       isolate()->factory()->NewFixedTypedArray(
1944           static_cast<int>(number_of_elements), array_type, true);
1945   obj->set_elements(*elements);
1946   return obj;
1947 }
1948
1949
1950 Handle<JSDataView> Factory::NewJSDataView(Handle<JSArrayBuffer> buffer,
1951                                           size_t byte_offset,
1952                                           size_t byte_length) {
1953   Handle<JSDataView> obj = NewJSDataView();
1954   SetupArrayBufferView(isolate(), obj, buffer, byte_offset, byte_length);
1955   return obj;
1956 }
1957
1958
1959 Handle<JSProxy> Factory::NewJSProxy(Handle<Object> handler,
1960                                     Handle<Object> prototype) {
1961   // Allocate map.
1962   // TODO(rossberg): Once we optimize proxies, think about a scheme to share
1963   // maps. Will probably depend on the identity of the handler object, too.
1964   Handle<Map> map = NewMap(JS_PROXY_TYPE, JSProxy::kSize);
1965   Map::SetPrototype(map, prototype);
1966
1967   // Allocate the proxy object.
1968   Handle<JSProxy> result = New<JSProxy>(map, NEW_SPACE);
1969   result->InitializeBody(map->instance_size(), Smi::FromInt(0));
1970   result->set_handler(*handler);
1971   result->set_hash(*undefined_value(), SKIP_WRITE_BARRIER);
1972   return result;
1973 }
1974
1975
1976 Handle<JSProxy> Factory::NewJSFunctionProxy(Handle<Object> handler,
1977                                             Handle<Object> call_trap,
1978                                             Handle<Object> construct_trap,
1979                                             Handle<Object> prototype) {
1980   // Allocate map.
1981   // TODO(rossberg): Once we optimize proxies, think about a scheme to share
1982   // maps. Will probably depend on the identity of the handler object, too.
1983   Handle<Map> map = NewMap(JS_FUNCTION_PROXY_TYPE, JSFunctionProxy::kSize);
1984   Map::SetPrototype(map, prototype);
1985
1986   // Allocate the proxy object.
1987   Handle<JSFunctionProxy> result = New<JSFunctionProxy>(map, NEW_SPACE);
1988   result->InitializeBody(map->instance_size(), Smi::FromInt(0));
1989   result->set_handler(*handler);
1990   result->set_hash(*undefined_value(), SKIP_WRITE_BARRIER);
1991   result->set_call_trap(*call_trap);
1992   result->set_construct_trap(*construct_trap);
1993   return result;
1994 }
1995
1996
1997 void Factory::ReinitializeJSProxy(Handle<JSProxy> proxy, InstanceType type,
1998                                   int size) {
1999   DCHECK(type == JS_OBJECT_TYPE || type == JS_FUNCTION_TYPE);
2000
2001   Handle<Map> proxy_map(proxy->map());
2002   Handle<Map> map = Map::FixProxy(proxy_map, type, size);
2003
2004   // Check that the receiver has at least the size of the fresh object.
2005   int size_difference = proxy_map->instance_size() - map->instance_size();
2006   DCHECK(size_difference >= 0);
2007
2008   // Allocate the backing storage for the properties.
2009   Handle<FixedArray> properties = empty_fixed_array();
2010
2011   Heap* heap = isolate()->heap();
2012   MaybeHandle<SharedFunctionInfo> shared;
2013   if (type == JS_FUNCTION_TYPE) {
2014     OneByteStringKey key(STATIC_CHAR_VECTOR("<freezing call trap>"),
2015                          heap->HashSeed());
2016     Handle<String> name = InternalizeStringWithKey(&key);
2017     shared = NewSharedFunctionInfo(name, MaybeHandle<Code>());
2018   }
2019
2020   // In order to keep heap in consistent state there must be no allocations
2021   // before object re-initialization is finished and filler object is installed.
2022   DisallowHeapAllocation no_allocation;
2023
2024   // Put in filler if the new object is smaller than the old.
2025   if (size_difference > 0) {
2026     Address address = proxy->address();
2027     heap->CreateFillerObjectAt(address + map->instance_size(), size_difference);
2028     heap->AdjustLiveBytes(address, -size_difference,
2029                           Heap::CONCURRENT_TO_SWEEPER);
2030   }
2031
2032   // Reset the map for the object.
2033   proxy->synchronized_set_map(*map);
2034   Handle<JSObject> jsobj = Handle<JSObject>::cast(proxy);
2035
2036   // Reinitialize the object from the constructor map.
2037   heap->InitializeJSObjectFromMap(*jsobj, *properties, *map);
2038
2039   // The current native context is used to set up certain bits.
2040   // TODO(adamk): Using the current context seems wrong, it should be whatever
2041   // context the JSProxy originated in. But that context isn't stored anywhere.
2042   Handle<Context> context(isolate()->native_context());
2043
2044   // Functions require some minimal initialization.
2045   if (type == JS_FUNCTION_TYPE) {
2046     map->set_function_with_prototype(true);
2047     Handle<JSFunction> js_function = Handle<JSFunction>::cast(proxy);
2048     InitializeFunction(js_function, shared.ToHandleChecked(), context);
2049   } else {
2050     // Provide JSObjects with a constructor.
2051     map->SetConstructor(context->object_function());
2052   }
2053 }
2054
2055
2056 Handle<JSGlobalProxy> Factory::NewUninitializedJSGlobalProxy() {
2057   // Create an empty shell of a JSGlobalProxy that needs to be reinitialized
2058   // via ReinitializeJSGlobalProxy later.
2059   Handle<Map> map = NewMap(JS_GLOBAL_PROXY_TYPE, JSGlobalProxy::kSize);
2060   // Maintain invariant expected from any JSGlobalProxy.
2061   map->set_is_access_check_needed(true);
2062   CALL_HEAP_FUNCTION(
2063       isolate(), isolate()->heap()->AllocateJSObjectFromMap(*map, NOT_TENURED),
2064       JSGlobalProxy);
2065 }
2066
2067
2068 void Factory::ReinitializeJSGlobalProxy(Handle<JSGlobalProxy> object,
2069                                         Handle<JSFunction> constructor) {
2070   DCHECK(constructor->has_initial_map());
2071   Handle<Map> map(constructor->initial_map(), isolate());
2072
2073   // The proxy's hash should be retained across reinitialization.
2074   Handle<Object> hash(object->hash(), isolate());
2075
2076   // Check that the already allocated object has the same size and type as
2077   // objects allocated using the constructor.
2078   DCHECK(map->instance_size() == object->map()->instance_size());
2079   DCHECK(map->instance_type() == object->map()->instance_type());
2080
2081   // Allocate the backing storage for the properties.
2082   Handle<FixedArray> properties = empty_fixed_array();
2083
2084   // In order to keep heap in consistent state there must be no allocations
2085   // before object re-initialization is finished.
2086   DisallowHeapAllocation no_allocation;
2087
2088   // Reset the map for the object.
2089   object->synchronized_set_map(*map);
2090
2091   Heap* heap = isolate()->heap();
2092   // Reinitialize the object from the constructor map.
2093   heap->InitializeJSObjectFromMap(*object, *properties, *map);
2094
2095   // Restore the saved hash.
2096   object->set_hash(*hash);
2097 }
2098
2099
2100 void Factory::BecomeJSObject(Handle<JSProxy> proxy) {
2101   ReinitializeJSProxy(proxy, JS_OBJECT_TYPE, JSObject::kHeaderSize);
2102 }
2103
2104
2105 void Factory::BecomeJSFunction(Handle<JSProxy> proxy) {
2106   ReinitializeJSProxy(proxy, JS_FUNCTION_TYPE, JSFunction::kSize);
2107 }
2108
2109
2110 template Handle<TypeFeedbackVector> Factory::NewTypeFeedbackVector(
2111     const ZoneFeedbackVectorSpec* spec);
2112 template Handle<TypeFeedbackVector> Factory::NewTypeFeedbackVector(
2113     const FeedbackVectorSpec* spec);
2114
2115 template <typename Spec>
2116 Handle<TypeFeedbackVector> Factory::NewTypeFeedbackVector(const Spec* spec) {
2117   return TypeFeedbackVector::Allocate<Spec>(isolate(), spec);
2118 }
2119
2120
2121 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
2122     Handle<String> name, int number_of_literals, FunctionKind kind,
2123     Handle<Code> code, Handle<ScopeInfo> scope_info,
2124     Handle<TypeFeedbackVector> feedback_vector) {
2125   DCHECK(IsValidFunctionKind(kind));
2126   Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(name, code);
2127   shared->set_scope_info(*scope_info);
2128   shared->set_feedback_vector(*feedback_vector);
2129   shared->set_kind(kind);
2130   shared->set_num_literals(number_of_literals);
2131   if (IsGeneratorFunction(kind)) {
2132     shared->set_instance_class_name(isolate()->heap()->Generator_string());
2133     shared->DisableOptimization(kGenerator);
2134   }
2135   return shared;
2136 }
2137
2138
2139 Handle<JSMessageObject> Factory::NewJSMessageObject(
2140     MessageTemplate::Template message, Handle<Object> argument,
2141     int start_position, int end_position, Handle<Object> script,
2142     Handle<Object> stack_frames) {
2143   Handle<Map> map = message_object_map();
2144   Handle<JSMessageObject> message_obj = New<JSMessageObject>(map, NEW_SPACE);
2145   message_obj->set_properties(*empty_fixed_array(), SKIP_WRITE_BARRIER);
2146   message_obj->initialize_elements();
2147   message_obj->set_elements(*empty_fixed_array(), SKIP_WRITE_BARRIER);
2148   message_obj->set_type(message);
2149   message_obj->set_argument(*argument);
2150   message_obj->set_start_position(start_position);
2151   message_obj->set_end_position(end_position);
2152   message_obj->set_script(*script);
2153   message_obj->set_stack_frames(*stack_frames);
2154   return message_obj;
2155 }
2156
2157
2158 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
2159     Handle<String> name,
2160     MaybeHandle<Code> maybe_code) {
2161   Handle<Map> map = shared_function_info_map();
2162   Handle<SharedFunctionInfo> share = New<SharedFunctionInfo>(map, OLD_SPACE);
2163
2164   // Set pointer fields.
2165   share->set_name(*name);
2166   Handle<Code> code;
2167   if (!maybe_code.ToHandle(&code)) {
2168     code = handle(isolate()->builtins()->builtin(Builtins::kIllegal));
2169   }
2170   share->set_code(*code);
2171   share->set_optimized_code_map(Smi::FromInt(0));
2172   share->set_scope_info(ScopeInfo::Empty(isolate()));
2173   Code* construct_stub =
2174       isolate()->builtins()->builtin(Builtins::kJSConstructStubGeneric);
2175   share->set_construct_stub(construct_stub);
2176   share->set_instance_class_name(*Object_string());
2177   share->set_function_data(*undefined_value(), SKIP_WRITE_BARRIER);
2178   share->set_script(*undefined_value(), SKIP_WRITE_BARRIER);
2179   share->set_debug_info(*undefined_value(), SKIP_WRITE_BARRIER);
2180   share->set_inferred_name(*empty_string(), SKIP_WRITE_BARRIER);
2181   FeedbackVectorSpec empty_spec(0);
2182   Handle<TypeFeedbackVector> feedback_vector =
2183       NewTypeFeedbackVector(&empty_spec);
2184   share->set_feedback_vector(*feedback_vector, SKIP_WRITE_BARRIER);
2185 #if TRACE_MAPS
2186   share->set_unique_id(isolate()->GetNextUniqueSharedFunctionInfoId());
2187 #endif
2188   share->set_profiler_ticks(0);
2189   share->set_ast_node_count(0);
2190   share->set_counters(0);
2191
2192   // Set integer fields (smi or int, depending on the architecture).
2193   share->set_length(0);
2194   share->set_internal_formal_parameter_count(0);
2195   share->set_expected_nof_properties(0);
2196   share->set_num_literals(0);
2197   share->set_start_position_and_type(0);
2198   share->set_end_position(0);
2199   share->set_function_token_position(0);
2200   // All compiler hints default to false or 0.
2201   share->set_compiler_hints(0);
2202   share->set_opt_count_and_bailout_reason(0);
2203
2204   return share;
2205 }
2206
2207
2208 static inline int NumberCacheHash(Handle<FixedArray> cache,
2209                                   Handle<Object> number) {
2210   int mask = (cache->length() >> 1) - 1;
2211   if (number->IsSmi()) {
2212     return Handle<Smi>::cast(number)->value() & mask;
2213   } else {
2214     DoubleRepresentation rep(number->Number());
2215     return
2216         (static_cast<int>(rep.bits) ^ static_cast<int>(rep.bits >> 32)) & mask;
2217   }
2218 }
2219
2220
2221 Handle<Object> Factory::GetNumberStringCache(Handle<Object> number) {
2222   DisallowHeapAllocation no_gc;
2223   int hash = NumberCacheHash(number_string_cache(), number);
2224   Object* key = number_string_cache()->get(hash * 2);
2225   if (key == *number || (key->IsHeapNumber() && number->IsHeapNumber() &&
2226                          key->Number() == number->Number())) {
2227     return Handle<String>(
2228         String::cast(number_string_cache()->get(hash * 2 + 1)), isolate());
2229   }
2230   return undefined_value();
2231 }
2232
2233
2234 void Factory::SetNumberStringCache(Handle<Object> number,
2235                                    Handle<String> string) {
2236   int hash = NumberCacheHash(number_string_cache(), number);
2237   if (number_string_cache()->get(hash * 2) != *undefined_value()) {
2238     int full_size = isolate()->heap()->FullSizeNumberStringCacheLength();
2239     if (number_string_cache()->length() != full_size) {
2240       Handle<FixedArray> new_cache = NewFixedArray(full_size, TENURED);
2241       isolate()->heap()->set_number_string_cache(*new_cache);
2242       return;
2243     }
2244   }
2245   number_string_cache()->set(hash * 2, *number);
2246   number_string_cache()->set(hash * 2 + 1, *string);
2247 }
2248
2249
2250 Handle<String> Factory::NumberToString(Handle<Object> number,
2251                                        bool check_number_string_cache) {
2252   isolate()->counters()->number_to_string_runtime()->Increment();
2253   if (check_number_string_cache) {
2254     Handle<Object> cached = GetNumberStringCache(number);
2255     if (!cached->IsUndefined()) return Handle<String>::cast(cached);
2256   }
2257
2258   char arr[100];
2259   Vector<char> buffer(arr, arraysize(arr));
2260   const char* str;
2261   if (number->IsSmi()) {
2262     int num = Handle<Smi>::cast(number)->value();
2263     str = IntToCString(num, buffer);
2264   } else {
2265     double num = Handle<HeapNumber>::cast(number)->value();
2266     str = DoubleToCString(num, buffer);
2267   }
2268
2269   // We tenure the allocated string since it is referenced from the
2270   // number-string cache which lives in the old space.
2271   Handle<String> js_string = NewStringFromAsciiChecked(str, TENURED);
2272   SetNumberStringCache(number, js_string);
2273   return js_string;
2274 }
2275
2276
2277 Handle<DebugInfo> Factory::NewDebugInfo(Handle<SharedFunctionInfo> shared) {
2278   // Allocate initial fixed array for active break points before allocating the
2279   // debug info object to avoid allocation while setting up the debug info
2280   // object.
2281   Handle<FixedArray> break_points(
2282       NewFixedArray(DebugInfo::kEstimatedNofBreakPointsInFunction));
2283
2284   // Create and set up the debug info object. Debug info contains function, a
2285   // copy of the original code, the executing code and initial fixed array for
2286   // active break points.
2287   Handle<DebugInfo> debug_info =
2288       Handle<DebugInfo>::cast(NewStruct(DEBUG_INFO_TYPE));
2289   debug_info->set_shared(*shared);
2290   debug_info->set_code(shared->code());
2291   debug_info->set_break_points(*break_points);
2292
2293   // Link debug info to function.
2294   shared->set_debug_info(*debug_info);
2295
2296   return debug_info;
2297 }
2298
2299
2300 Handle<JSObject> Factory::NewArgumentsObject(Handle<JSFunction> callee,
2301                                              int length) {
2302   bool strict_mode_callee = is_strict(callee->shared()->language_mode()) ||
2303                             !callee->is_simple_parameter_list();
2304   Handle<Map> map = strict_mode_callee ? isolate()->strict_arguments_map()
2305                                        : isolate()->sloppy_arguments_map();
2306
2307   AllocationSiteUsageContext context(isolate(), Handle<AllocationSite>(),
2308                                      false);
2309   DCHECK(!isolate()->has_pending_exception());
2310   Handle<JSObject> result = NewJSObjectFromMap(map);
2311   Handle<Smi> value(Smi::FromInt(length), isolate());
2312   Object::SetProperty(result, length_string(), value, STRICT).Assert();
2313   if (!strict_mode_callee) {
2314     Object::SetProperty(result, callee_string(), callee, STRICT).Assert();
2315   }
2316   return result;
2317 }
2318
2319
2320 Handle<JSWeakMap> Factory::NewJSWeakMap() {
2321   // TODO(adamk): Currently the map is only created three times per
2322   // isolate. If it's created more often, the map should be moved into the
2323   // strong root list.
2324   Handle<Map> map = NewMap(JS_WEAK_MAP_TYPE, JSWeakMap::kSize);
2325   return Handle<JSWeakMap>::cast(NewJSObjectFromMap(map));
2326 }
2327
2328
2329 Handle<Map> Factory::ObjectLiteralMapFromCache(Handle<Context> context,
2330                                                int number_of_properties,
2331                                                bool is_strong,
2332                                                bool* is_result_from_cache) {
2333   const int kMapCacheSize = 128;
2334
2335   // We do not cache maps for too many properties or when running builtin code.
2336   if (number_of_properties > kMapCacheSize ||
2337       isolate()->bootstrapper()->IsActive()) {
2338     *is_result_from_cache = false;
2339     Handle<Map> map = Map::Create(isolate(), number_of_properties);
2340     if (is_strong) map->set_is_strong();
2341     return map;
2342   }
2343   *is_result_from_cache = true;
2344   if (number_of_properties == 0) {
2345     // Reuse the initial map of the Object function if the literal has no
2346     // predeclared properties, or the strong map if strong.
2347     return handle(is_strong
2348                       ? context->js_object_strong_map()
2349                       : context->object_function()->initial_map(), isolate());
2350   }
2351
2352   int cache_index = number_of_properties - 1;
2353   Handle<Object> maybe_cache(is_strong ? context->strong_map_cache()
2354                                        : context->map_cache(), isolate());
2355   if (maybe_cache->IsUndefined()) {
2356     // Allocate the new map cache for the native context.
2357     maybe_cache = NewFixedArray(kMapCacheSize, TENURED);
2358     if (is_strong) {
2359       context->set_strong_map_cache(*maybe_cache);
2360     } else {
2361       context->set_map_cache(*maybe_cache);
2362     }
2363   } else {
2364     // Check to see whether there is a matching element in the cache.
2365     Handle<FixedArray> cache = Handle<FixedArray>::cast(maybe_cache);
2366     Object* result = cache->get(cache_index);
2367     if (result->IsWeakCell()) {
2368       WeakCell* cell = WeakCell::cast(result);
2369       if (!cell->cleared()) {
2370         return handle(Map::cast(cell->value()), isolate());
2371       }
2372     }
2373   }
2374   // Create a new map and add it to the cache.
2375   Handle<FixedArray> cache = Handle<FixedArray>::cast(maybe_cache);
2376   Handle<Map> map = Map::Create(isolate(), number_of_properties);
2377   if (is_strong) map->set_is_strong();
2378   Handle<WeakCell> cell = NewWeakCell(map);
2379   cache->set(cache_index, *cell);
2380   return map;
2381 }
2382
2383
2384 void Factory::SetRegExpAtomData(Handle<JSRegExp> regexp,
2385                                 JSRegExp::Type type,
2386                                 Handle<String> source,
2387                                 JSRegExp::Flags flags,
2388                                 Handle<Object> data) {
2389   Handle<FixedArray> store = NewFixedArray(JSRegExp::kAtomDataSize);
2390
2391   store->set(JSRegExp::kTagIndex, Smi::FromInt(type));
2392   store->set(JSRegExp::kSourceIndex, *source);
2393   store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value()));
2394   store->set(JSRegExp::kAtomPatternIndex, *data);
2395   regexp->set_data(*store);
2396 }
2397
2398
2399 void Factory::SetRegExpIrregexpData(Handle<JSRegExp> regexp,
2400                                     JSRegExp::Type type,
2401                                     Handle<String> source,
2402                                     JSRegExp::Flags flags,
2403                                     int capture_count) {
2404   Handle<FixedArray> store = NewFixedArray(JSRegExp::kIrregexpDataSize);
2405   Smi* uninitialized = Smi::FromInt(JSRegExp::kUninitializedValue);
2406   store->set(JSRegExp::kTagIndex, Smi::FromInt(type));
2407   store->set(JSRegExp::kSourceIndex, *source);
2408   store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value()));
2409   store->set(JSRegExp::kIrregexpLatin1CodeIndex, uninitialized);
2410   store->set(JSRegExp::kIrregexpUC16CodeIndex, uninitialized);
2411   store->set(JSRegExp::kIrregexpLatin1CodeSavedIndex, uninitialized);
2412   store->set(JSRegExp::kIrregexpUC16CodeSavedIndex, uninitialized);
2413   store->set(JSRegExp::kIrregexpMaxRegisterCountIndex, Smi::FromInt(0));
2414   store->set(JSRegExp::kIrregexpCaptureCountIndex,
2415              Smi::FromInt(capture_count));
2416   regexp->set_data(*store);
2417 }
2418
2419
2420 Handle<Object> Factory::GlobalConstantFor(Handle<Name> name) {
2421   if (Name::Equals(name, undefined_string())) return undefined_value();
2422   if (Name::Equals(name, nan_string())) return nan_value();
2423   if (Name::Equals(name, infinity_string())) return infinity_value();
2424   return Handle<Object>::null();
2425 }
2426
2427
2428 Handle<Object> Factory::ToBoolean(bool value) {
2429   return value ? true_value() : false_value();
2430 }
2431
2432
2433 }  // namespace internal
2434 }  // namespace v8