factory.cc 86.6 KB
Newer Older
1 2 3 4
// Copyright 2014 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

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 11
#include "src/conversions.h"
#include "src/macro-assembler.h"
12

13 14
namespace v8 {
namespace internal {
15

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

template<typename T>
Handle<T> Factory::New(Handle<Map> map, AllocationSpace space) {
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->Allocate(*map, space),
      T);
}


template<typename T>
Handle<T> Factory::New(Handle<Map> map,
                       AllocationSpace space,
                       Handle<AllocationSite> allocation_site) {
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->Allocate(*map, space, *allocation_site),
      T);
}


37 38 39 40 41 42 43 44 45 46
Handle<HeapObject> Factory::NewFillerObject(int size,
                                            bool double_align,
                                            AllocationSpace space) {
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateFillerObject(size, double_align, space),
      HeapObject);
}


47 48 49 50
Handle<Box> Factory::NewBox(Handle<Object> value) {
  Handle<Box> result = Handle<Box>::cast(NewStruct(BOX_TYPE));
  result->set_value(*value);
  return result;
51 52 53
}


54 55 56 57 58
Handle<PrototypeInfo> Factory::NewPrototypeInfo() {
  Handle<PrototypeInfo> result =
      Handle<PrototypeInfo>::cast(NewStruct(PROTOTYPE_INFO_TYPE));
  result->set_prototype_users(WeakFixedArray::Empty());
  result->set_validity_cell(Smi::FromInt(0));
59
  result->set_constructor_name(Smi::FromInt(0));
60 61 62 63
  return result;
}


64 65 66 67
Handle<Oddball> Factory::NewOddball(Handle<Map> map,
                                    const char* to_string,
                                    Handle<Object> to_number,
                                    byte kind) {
68
  Handle<Oddball> oddball = New<Oddball>(map, OLD_SPACE);
69 70 71 72 73
  Oddball::Initialize(isolate(), oddball, to_string, to_number, kind);
  return oddball;
}


74
Handle<FixedArray> Factory::NewFixedArray(int size, PretenureFlag pretenure) {
75
  DCHECK(0 <= size);
76 77 78 79
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateFixedArray(size, pretenure),
      FixedArray);
80 81 82
}


83 84
Handle<FixedArray> Factory::NewFixedArrayWithHoles(int size,
                                                   PretenureFlag pretenure) {
85
  DCHECK(0 <= size);
86 87
  CALL_HEAP_FUNCTION(
      isolate(),
88 89 90
      isolate()->heap()->AllocateFixedArrayWithFiller(size,
                                                      pretenure,
                                                      *the_hole_value()),
91
      FixedArray);
92 93 94
}


95 96 97 98 99 100 101 102
Handle<FixedArray> Factory::NewUninitializedFixedArray(int size) {
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateUninitializedFixedArray(size),
      FixedArray);
}


103
Handle<FixedArrayBase> Factory::NewFixedDoubleArray(int size,
104
                                                    PretenureFlag pretenure) {
105
  DCHECK(0 <= size);
106 107 108
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateUninitializedFixedDoubleArray(size, pretenure),
109
      FixedArrayBase);
110 111 112
}


113
Handle<FixedArrayBase> Factory::NewFixedDoubleArrayWithHoles(
114 115
    int size,
    PretenureFlag pretenure) {
116
  DCHECK(0 <= size);
117 118 119 120 121 122 123
  Handle<FixedArrayBase> array = NewFixedDoubleArray(size, pretenure);
  if (size > 0) {
    Handle<FixedDoubleArray> double_array =
        Handle<FixedDoubleArray>::cast(array);
    for (int i = 0; i < size; ++i) {
      double_array->set_the_hole(i);
    }
124 125 126 127 128
  }
  return array;
}


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 141 142 143 144
  Handle<AccessorPair> accessors =
      Handle<AccessorPair>::cast(NewStruct(ACCESSOR_PAIR_TYPE));
  accessors->set_getter(*the_hole_value(), SKIP_WRITE_BARRIER);
  accessors->set_setter(*the_hole_value(), SKIP_WRITE_BARRIER);
  return accessors;
145 146 147
}


148
Handle<TypeFeedbackInfo> Factory::NewTypeFeedbackInfo() {
149 150 151 152
  Handle<TypeFeedbackInfo> info =
      Handle<TypeFeedbackInfo>::cast(NewStruct(TYPE_FEEDBACK_INFO_TYPE));
  info->initialize_storage();
  return info;
153 154 155
}


156 157
// Internalized strings are created in the old generation (data space).
Handle<String> Factory::InternalizeUtf8String(Vector<const char> string) {
158 159
  Utf8StringKey key(string, isolate()->heap()->HashSeed());
  return InternalizeStringWithKey(&key);
160 161
}

162

163 164
// Internalized strings are created in the old generation (data space).
Handle<String> Factory::InternalizeString(Handle<String> string) {
165 166
  if (string->IsInternalizedString()) return string;
  return StringTable::LookupString(isolate(), string);
167 168
}

169

170
Handle<String> Factory::InternalizeOneByteString(Vector<const uint8_t> string) {
171 172
  OneByteStringKey key(string, isolate()->heap()->HashSeed());
  return InternalizeStringWithKey(&key);
173 174
}

175

176 177
Handle<String> Factory::InternalizeOneByteString(
    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 185 186 187 188 189 190
  TwoByteStringKey key(string, isolate()->heap()->HashSeed());
  return InternalizeStringWithKey(&key);
}


template<class StringTableKey>
Handle<String> Factory::InternalizeStringWithKey(StringTableKey* key) {
191
  return StringTable::LookupKey(isolate(), key);
192 193
}

194

195 196 197
MaybeHandle<String> Factory::NewStringFromOneByte(Vector<const uint8_t> string,
                                                  PretenureFlag pretenure) {
  int length = string.length();
198
  if (length == 1) return LookupSingleCharacterStringFromCode(string[0]);
199 200
  Handle<SeqOneByteString> result;
  ASSIGN_RETURN_ON_EXCEPTION(
201
      isolate(),
202 203
      result,
      NewRawOneByteString(string.length(), pretenure),
204
      String);
205 206 207 208 209 210 211

  DisallowHeapAllocation no_gc;
  // Copy the characters into the new object.
  CopyChars(SeqOneByteString::cast(*result)->GetChars(),
            string.start(),
            length);
  return result;
212 213
}

214 215
MaybeHandle<String> Factory::NewStringFromUtf8(Vector<const char> string,
                                               PretenureFlag pretenure) {
216 217 218 219 220 221 222 223 224
  // Check for ASCII first since this is the common case.
  const char* start = string.start();
  int length = string.length();
  int non_ascii_start = String::NonAsciiStart(start, length);
  if (non_ascii_start >= length) {
    // If the string is ASCII, we do not need to convert the characters
    // since UTF8 is backwards compatible with ASCII.
    return NewStringFromOneByte(Vector<const uint8_t>::cast(string), pretenure);
  }
225

226
  // Non-ASCII and we need to decode.
227 228 229 230
  Access<UnicodeCache::Utf8Decoder>
      decoder(isolate()->unicode_cache()->utf8_decoder());
  decoder->Reset(string.start() + non_ascii_start,
                 length - non_ascii_start);
231
  int utf16_length = static_cast<int>(decoder->Utf16Length());
232
  DCHECK(utf16_length > 0);
233 234 235 236 237
  // Allocate string.
  Handle<SeqTwoByteString> result;
  ASSIGN_RETURN_ON_EXCEPTION(
      isolate(), result,
      NewRawTwoByteString(non_ascii_start + utf16_length, pretenure),
238
      String);
239
  // Copy ASCII portion.
240 241 242 243 244 245 246 247
  uint16_t* data = result->GetChars();
  const char* ascii_data = string.start();
  for (int i = 0; i < non_ascii_start; i++) {
    *data++ = *ascii_data++;
  }
  // Now write the remainder.
  decoder->WriteUtf16(data, utf16_length);
  return result;
248 249 250
}


251 252
MaybeHandle<String> Factory::NewStringFromTwoByte(Vector<const uc16> string,
                                                  PretenureFlag pretenure) {
253 254 255
  int length = string.length();
  const uc16* start = string.start();
  if (String::IsOneByte(start, length)) {
256
    if (length == 1) return LookupSingleCharacterStringFromCode(string[0]);
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
    Handle<SeqOneByteString> result;
    ASSIGN_RETURN_ON_EXCEPTION(
        isolate(),
        result,
        NewRawOneByteString(length, pretenure),
        String);
    CopyChars(result->GetChars(), start, length);
    return result;
  } else {
    Handle<SeqTwoByteString> result;
    ASSIGN_RETURN_ON_EXCEPTION(
        isolate(),
        result,
        NewRawTwoByteString(length, pretenure),
        String);
    CopyChars(result->GetChars(), start, length);
    return result;
  }
275 276 277
}


278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
Handle<String> Factory::NewInternalizedStringFromUtf8(Vector<const char> str,
                                                      int chars,
                                                      uint32_t hash_field) {
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateInternalizedStringFromUtf8(
          str, chars, hash_field),
      String);
}


MUST_USE_RESULT Handle<String> Factory::NewOneByteInternalizedString(
      Vector<const uint8_t> str,
      uint32_t hash_field) {
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateOneByteInternalizedString(str, hash_field),
      String);
}


299 300 301 302 303 304 305 306 307 308 309
MUST_USE_RESULT Handle<String> Factory::NewOneByteInternalizedSubString(
    Handle<SeqOneByteString> string, int offset, int length,
    uint32_t hash_field) {
  CALL_HEAP_FUNCTION(
      isolate(), isolate()->heap()->AllocateOneByteInternalizedString(
                     Vector<const uint8_t>(string->GetChars() + offset, length),
                     hash_field),
      String);
}


310 311 312 313 314 315 316 317 318 319 320
MUST_USE_RESULT Handle<String> Factory::NewTwoByteInternalizedString(
      Vector<const uc16> str,
      uint32_t hash_field) {
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateTwoByteInternalizedString(str, hash_field),
      String);
}


Handle<String> Factory::NewInternalizedStringImpl(
321
    Handle<String> string, int chars, uint32_t hash_field) {
322 323
  CALL_HEAP_FUNCTION(
      isolate(),
324 325
      isolate()->heap()->AllocateInternalizedStringImpl(
          *string, chars, hash_field),
326 327 328 329 330 331 332 333 334 335 336 337
      String);
}


MaybeHandle<Map> Factory::InternalizedStringMapForString(
    Handle<String> string) {
  // If the string is in new space it cannot be used as internalized.
  if (isolate()->heap()->InNewSpace(*string)) return MaybeHandle<Map>();

  // Find the corresponding internalized string map for strings.
  switch (string->map()->instance_type()) {
    case STRING_TYPE: return internalized_string_map();
338 339
    case ONE_BYTE_STRING_TYPE:
      return one_byte_internalized_string_map();
340
    case EXTERNAL_STRING_TYPE: return external_internalized_string_map();
341 342
    case EXTERNAL_ONE_BYTE_STRING_TYPE:
      return external_one_byte_internalized_string_map();
343 344 345 346
    case EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE:
      return external_internalized_string_with_one_byte_data_map();
    case SHORT_EXTERNAL_STRING_TYPE:
      return short_external_internalized_string_map();
347 348
    case SHORT_EXTERNAL_ONE_BYTE_STRING_TYPE:
      return short_external_one_byte_internalized_string_map();
349 350 351 352 353 354 355
    case SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE:
      return short_external_internalized_string_with_one_byte_data_map();
    default: return MaybeHandle<Map>();  // No match found.
  }
}


356 357
MaybeHandle<SeqOneByteString> Factory::NewRawOneByteString(
    int length, PretenureFlag pretenure) {
358
  if (length > String::kMaxLength || length < 0) {
359
    THROW_NEW_ERROR(isolate(), NewInvalidStringLengthError(), SeqOneByteString);
360
  }
361 362
  CALL_HEAP_FUNCTION(
      isolate(),
363
      isolate()->heap()->AllocateRawOneByteString(length, pretenure),
364
      SeqOneByteString);
365 366 367
}


368 369
MaybeHandle<SeqTwoByteString> Factory::NewRawTwoByteString(
    int length, PretenureFlag pretenure) {
370
  if (length > String::kMaxLength || length < 0) {
371
    THROW_NEW_ERROR(isolate(), NewInvalidStringLengthError(), SeqTwoByteString);
372
  }
373 374 375
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateRawTwoByteString(length, pretenure),
376
      SeqTwoByteString);
377 378 379
}


380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
Handle<String> Factory::LookupSingleCharacterStringFromCode(uint32_t code) {
  if (code <= String::kMaxOneByteCharCodeU) {
    {
      DisallowHeapAllocation no_allocation;
      Object* value = single_character_string_cache()->get(code);
      if (value != *undefined_value()) {
        return handle(String::cast(value), isolate());
      }
    }
    uint8_t buffer[1];
    buffer[0] = static_cast<uint8_t>(code);
    Handle<String> result =
        InternalizeOneByteString(Vector<const uint8_t>(buffer, 1));
    single_character_string_cache()->set(code, *result);
    return result;
  }
396
  DCHECK(code <= String::kMaxUtf16CodeUnitU);
397 398 399 400

  Handle<SeqTwoByteString> result = NewRawTwoByteString(1).ToHandleChecked();
  result->SeqTwoByteStringSet(0, static_cast<uint16_t>(code));
  return result;
401 402 403
}


404 405 406 407 408 409 410 411 412 413 414 415 416
// Returns true for a character in a range.  Both limits are inclusive.
static inline bool Between(uint32_t character, uint32_t from, uint32_t to) {
  // This makes uses of the the unsigned wraparound.
  return character - from <= to - from;
}


static inline Handle<String> MakeOrFindTwoCharacterString(Isolate* isolate,
                                                          uint16_t c1,
                                                          uint16_t c2) {
  // Numeric strings have a different hash algorithm not known by
  // LookupTwoCharsStringIfExists, so we skip this step for such strings.
  if (!Between(c1, '0', '9') || !Between(c2, '0', '9')) {
417 418 419 420
    Handle<String> result;
    if (StringTable::LookupTwoCharsStringIfExists(isolate, c1, c2).
        ToHandle(&result)) {
      return result;
421 422 423 424 425 426 427
    }
  }

  // Now we know the length is 2, we might as well make use of that fact
  // when building the new string.
  if (static_cast<unsigned>(c1 | c2) <= String::kMaxOneByteCharCodeU) {
    // We can do this.
428 429
    DCHECK(base::bits::IsPowerOfTwo32(String::kMaxOneByteCharCodeU +
                                      1));  // because of this.
430 431
    Handle<SeqOneByteString> str =
        isolate->factory()->NewRawOneByteString(2).ToHandleChecked();
432 433 434 435 436
    uint8_t* dest = str->GetChars();
    dest[0] = static_cast<uint8_t>(c1);
    dest[1] = static_cast<uint8_t>(c2);
    return str;
  } else {
437 438
    Handle<SeqTwoByteString> str =
        isolate->factory()->NewRawTwoByteString(2).ToHandleChecked();
439 440 441 442 443
    uc16* dest = str->GetChars();
    dest[0] = c1;
    dest[1] = c2;
    return str;
  }
444 445 446
}


447 448 449 450 451 452 453 454 455 456 457 458
template<typename SinkChar, typename StringType>
Handle<String> ConcatStringContent(Handle<StringType> result,
                                   Handle<String> first,
                                   Handle<String> second) {
  DisallowHeapAllocation pointer_stays_valid;
  SinkChar* sink = result->GetChars();
  String::WriteToFlat(*first, sink, 0, first->length());
  String::WriteToFlat(*second, sink + first->length(), 0, second->length());
  return result;
}


459 460
MaybeHandle<String> Factory::NewConsString(Handle<String> left,
                                           Handle<String> right) {
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476
  int left_length = left->length();
  if (left_length == 0) return right;
  int right_length = right->length();
  if (right_length == 0) return left;

  int length = left_length + right_length;

  if (length == 2) {
    uint16_t c1 = left->Get(0);
    uint16_t c2 = right->Get(0);
    return MakeOrFindTwoCharacterString(isolate(), c1, c2);
  }

  // Make sure that an out of memory exception is thrown if the length
  // of the new cons string is too large.
  if (length > String::kMaxLength || length < 0) {
477
    THROW_NEW_ERROR(isolate(), NewInvalidStringLengthError(), String);
478 479 480 481 482 483 484 485
  }

  bool left_is_one_byte = left->IsOneByteRepresentation();
  bool right_is_one_byte = right->IsOneByteRepresentation();
  bool is_one_byte = left_is_one_byte && right_is_one_byte;
  bool is_one_byte_data_in_two_byte_string = false;
  if (!is_one_byte) {
    // At least one of the strings uses two-byte representation so we
486 487
    // can't use the fast case code for short one-byte strings below, but
    // we can try to save memory if all chars actually fit in one-byte.
488 489 490
    is_one_byte_data_in_two_byte_string =
        left->HasOnlyOneByteChars() && right->HasOnlyOneByteChars();
    if (is_one_byte_data_in_two_byte_string) {
491
      isolate()->counters()->string_add_runtime_ext_to_one_byte()->Increment();
492 493 494 495 496 497 498
    }
  }

  // If the resulting string is small make a flat string.
  if (length < ConsString::kMinLength) {
    // Note that neither of the two inputs can be a slice because:
    STATIC_ASSERT(ConsString::kMinLength <= SlicedString::kMinLength);
499 500
    DCHECK(left->IsFlat());
    DCHECK(right->IsFlat());
501

502
    STATIC_ASSERT(ConsString::kMinLength <= String::kMaxLength);
503
    if (is_one_byte) {
504 505
      Handle<SeqOneByteString> result =
          NewRawOneByteString(length).ToHandleChecked();
506 507 508
      DisallowHeapAllocation no_gc;
      uint8_t* dest = result->GetChars();
      // Copy left part.
509 510 511 512
      const uint8_t* src =
          left->IsExternalString()
              ? Handle<ExternalOneByteString>::cast(left)->GetChars()
              : Handle<SeqOneByteString>::cast(left)->GetChars();
513 514 515
      for (int i = 0; i < left_length; i++) *dest++ = src[i];
      // Copy right part.
      src = right->IsExternalString()
516 517
                ? Handle<ExternalOneByteString>::cast(right)->GetChars()
                : Handle<SeqOneByteString>::cast(right)->GetChars();
518 519 520 521 522
      for (int i = 0; i < right_length; i++) *dest++ = src[i];
      return result;
    }

    return (is_one_byte_data_in_two_byte_string)
523 524 525 526
        ? ConcatStringContent<uint8_t>(
            NewRawOneByteString(length).ToHandleChecked(), left, right)
        : ConcatStringContent<uc16>(
            NewRawTwoByteString(length).ToHandleChecked(), left, right);
527 528
  }

529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
  return (is_one_byte || is_one_byte_data_in_two_byte_string)
             ? NewOneByteConsString(length, left, right)
             : NewTwoByteConsString(length, left, right);
}


MaybeHandle<String> Factory::NewOneByteConsString(int length,
                                                  Handle<String> left,
                                                  Handle<String> right) {
  return NewRawConsString(cons_one_byte_string_map(), length, left, right);
}


MaybeHandle<String> Factory::NewTwoByteConsString(int length,
                                                  Handle<String> left,
                                                  Handle<String> right) {
  return NewRawConsString(cons_string_map(), length, left, right);
}


MaybeHandle<String> Factory::NewRawConsString(Handle<Map> map, int length,
                                              Handle<String> left,
                                              Handle<String> right) {
  Handle<ConsString> result = New<ConsString>(map, NEW_SPACE);
553 554 555 556 557 558 559 560 561 562 563 564

  DisallowHeapAllocation no_gc;
  WriteBarrierMode mode = result->GetWriteBarrierMode(no_gc);

  result->set_hash_field(String::kEmptyHashField);
  result->set_length(length);
  result->set_first(*left, mode);
  result->set_second(*right, mode);
  return result;
}


565
Handle<String> Factory::NewProperSubString(Handle<String> str,
566 567
                                           int begin,
                                           int end) {
568 569 570
#if VERIFY_HEAP
  if (FLAG_verify_heap) str->StringVerify();
#endif
571
  DCHECK(begin > 0 || end < str->length());
572

573 574
  str = String::Flatten(str);

575 576 577
  int length = end - begin;
  if (length <= 0) return empty_string();
  if (length == 1) {
578
    return LookupSingleCharacterStringFromCode(str->Get(begin));
579 580 581 582 583 584 585 586 587 588 589 590
  }
  if (length == 2) {
    // Optimization for 2-byte strings often used as keys in a decompression
    // dictionary.  Check whether we already have the string in the string
    // table to prevent creation of many unnecessary strings.
    uint16_t c1 = str->Get(begin);
    uint16_t c2 = str->Get(begin + 1);
    return MakeOrFindTwoCharacterString(isolate(), c1, c2);
  }

  if (!FLAG_string_slices || length < SlicedString::kMinLength) {
    if (str->IsOneByteRepresentation()) {
591 592
      Handle<SeqOneByteString> result =
          NewRawOneByteString(length).ToHandleChecked();
593 594 595 596 597
      uint8_t* dest = result->GetChars();
      DisallowHeapAllocation no_gc;
      String::WriteToFlat(*str, dest, begin, end);
      return result;
    } else {
598 599
      Handle<SeqTwoByteString> result =
          NewRawTwoByteString(length).ToHandleChecked();
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614
      uc16* dest = result->GetChars();
      DisallowHeapAllocation no_gc;
      String::WriteToFlat(*str, dest, begin, end);
      return result;
    }
  }

  int offset = begin;

  if (str->IsSlicedString()) {
    Handle<SlicedString> slice = Handle<SlicedString>::cast(str);
    str = Handle<String>(slice->parent(), isolate());
    offset += slice->offset();
  }

615
  DCHECK(str->IsSeqString() || str->IsExternalString());
616 617 618
  Handle<Map> map = str->IsOneByteRepresentation()
                        ? sliced_one_byte_string_map()
                        : sliced_string_map();
619
  Handle<SlicedString> slice = New<SlicedString>(map, NEW_SPACE);
620 621 622 623 624 625

  slice->set_hash_field(String::kEmptyHashField);
  slice->set_length(length);
  slice->set_parent(*str);
  slice->set_offset(offset);
  return slice;
626 627 628
}


629 630
MaybeHandle<String> Factory::NewExternalStringFromOneByte(
    const ExternalOneByteString::Resource* resource) {
631 632
  size_t length = resource->length();
  if (length > static_cast<size_t>(String::kMaxLength)) {
633
    THROW_NEW_ERROR(isolate(), NewInvalidStringLengthError(), String);
634 635
  }

636 637 638
  Handle<Map> map = external_one_byte_string_map();
  Handle<ExternalOneByteString> external_string =
      New<ExternalOneByteString>(map, NEW_SPACE);
639 640 641 642 643
  external_string->set_length(static_cast<int>(length));
  external_string->set_hash_field(String::kEmptyHashField);
  external_string->set_resource(resource);

  return external_string;
644 645 646
}


647
MaybeHandle<String> Factory::NewExternalStringFromTwoByte(
648
    const ExternalTwoByteString::Resource* resource) {
649 650
  size_t length = resource->length();
  if (length > static_cast<size_t>(String::kMaxLength)) {
651
    THROW_NEW_ERROR(isolate(), NewInvalidStringLengthError(), String);
652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
  }

  // For small strings we check whether the resource contains only
  // one byte characters.  If yes, we use a different string map.
  static const size_t kOneByteCheckLengthLimit = 32;
  bool is_one_byte = length <= kOneByteCheckLengthLimit &&
      String::IsOneByte(resource->data(), static_cast<int>(length));
  Handle<Map> map = is_one_byte ?
      external_string_with_one_byte_data_map() : external_string_map();
  Handle<ExternalTwoByteString> external_string =
      New<ExternalTwoByteString>(map, NEW_SPACE);
  external_string->set_length(static_cast<int>(length));
  external_string->set_hash_field(String::kEmptyHashField);
  external_string->set_resource(resource);

  return external_string;
668 669 670
}


671 672 673 674 675 676 677 678
Handle<Symbol> Factory::NewSymbol() {
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateSymbol(),
      Symbol);
}


679
Handle<Symbol> Factory::NewPrivateSymbol(Handle<Object> name) {
680 681
  Handle<Symbol> symbol = NewSymbol();
  symbol->set_is_private(true);
682 683 684 685 686
  if (name->IsString()) {
    symbol->set_name(*name);
  } else {
    DCHECK(name->IsUndefined());
  }
687 688 689 690
  return symbol;
}


691
Handle<Context> Factory::NewNativeContext() {
692 693
  Handle<FixedArray> array =
      NewFixedArray(Context::NATIVE_CONTEXT_SLOTS, TENURED);
694 695 696
  array->set_map_no_write_barrier(*native_context_map());
  Handle<Context> context = Handle<Context>::cast(array);
  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 705
  Handle<FixedArray> array =
      NewFixedArray(scope_info->ContextLength(), TENURED);
706
  array->set_map_no_write_barrier(*script_context_map());
707 708 709 710 711
  Handle<Context> context = Handle<Context>::cast(array);
  context->set_closure(*function);
  context->set_previous(function->context());
  context->set_extension(*scope_info);
  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 720 721
  array->set_map_no_write_barrier(*script_context_table_map());
  Handle<ScriptContextTable> context_table =
      Handle<ScriptContextTable>::cast(array);
722 723 724 725 726
  context_table->set_used(0);
  return context_table;
}


727
Handle<Context> Factory::NewModuleContext(Handle<ScopeInfo> scope_info) {
728 729 730 731 732 733 734
  Handle<FixedArray> array =
      NewFixedArray(scope_info->ContextLength(), TENURED);
  array->set_map_no_write_barrier(*module_context_map());
  // Instance link will be set later.
  Handle<Context> context = Handle<Context>::cast(array);
  context->set_extension(Smi::FromInt(0));
  return context;
735 736 737
}


738
Handle<Context> Factory::NewFunctionContext(int length,
739
                                            Handle<JSFunction> function) {
740
  DCHECK(length >= Context::MIN_CONTEXT_SLOTS);
741 742 743 744 745 746 747 748
  Handle<FixedArray> array = NewFixedArray(length);
  array->set_map_no_write_barrier(*function_context_map());
  Handle<Context> context = Handle<Context>::cast(array);
  context->set_closure(*function);
  context->set_previous(function->context());
  context->set_extension(Smi::FromInt(0));
  context->set_global_object(function->context()->global_object());
  return context;
749 750 751
}


752 753
Handle<Context> Factory::NewCatchContext(Handle<JSFunction> function,
                                         Handle<Context> previous,
754 755
                                         Handle<String> name,
                                         Handle<Object> thrown_object) {
756 757 758 759 760 761 762 763 764 765
  STATIC_ASSERT(Context::MIN_CONTEXT_SLOTS == Context::THROWN_OBJECT_INDEX);
  Handle<FixedArray> array = NewFixedArray(Context::MIN_CONTEXT_SLOTS + 1);
  array->set_map_no_write_barrier(*catch_context_map());
  Handle<Context> context = Handle<Context>::cast(array);
  context->set_closure(*function);
  context->set_previous(*previous);
  context->set_extension(*name);
  context->set_global_object(previous->global_object());
  context->set(Context::THROWN_OBJECT_INDEX, *thrown_object);
  return context;
766 767 768
}


769 770
Handle<Context> Factory::NewWithContext(Handle<JSFunction> function,
                                        Handle<Context> previous,
771 772 773 774 775 776 777 778 779
                                        Handle<JSReceiver> extension) {
  Handle<FixedArray> array = NewFixedArray(Context::MIN_CONTEXT_SLOTS);
  array->set_map_no_write_barrier(*with_context_map());
  Handle<Context> context = Handle<Context>::cast(array);
  context->set_closure(*function);
  context->set_previous(*previous);
  context->set_extension(*extension);
  context->set_global_object(previous->global_object());
  return context;
780 781 782
}


783 784 785
Handle<Context> Factory::NewBlockContext(Handle<JSFunction> function,
                                         Handle<Context> previous,
                                         Handle<ScopeInfo> scope_info) {
786 787 788 789 790 791 792 793 794
  Handle<FixedArray> array =
      NewFixedArrayWithHoles(scope_info->ContextLength());
  array->set_map_no_write_barrier(*block_context_map());
  Handle<Context> context = Handle<Context>::cast(array);
  context->set_closure(*function);
  context->set_previous(*previous);
  context->set_extension(*scope_info);
  context->set_global_object(previous->global_object());
  return context;
795 796 797
}


798
Handle<Struct> Factory::NewStruct(InstanceType type) {
799 800 801 802
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateStruct(type),
      Struct);
803 804 805
}


806
Handle<CodeCache> Factory::NewCodeCache() {
807 808 809 810 811
  Handle<CodeCache> code_cache =
      Handle<CodeCache>::cast(NewStruct(CODE_CACHE_TYPE));
  code_cache->set_default_cache(*empty_fixed_array(), SKIP_WRITE_BARRIER);
  code_cache->set_normal_type_cache(*undefined_value(), SKIP_WRITE_BARRIER);
  return code_cache;
812 813 814
}


815 816 817 818 819 820 821 822 823
Handle<AliasedArgumentsEntry> Factory::NewAliasedArgumentsEntry(
    int aliased_context_slot) {
  Handle<AliasedArgumentsEntry> entry = Handle<AliasedArgumentsEntry>::cast(
      NewStruct(ALIASED_ARGUMENTS_ENTRY_TYPE));
  entry->set_aliased_context_slot(aliased_context_slot);
  return entry;
}


824 825 826 827
Handle<ExecutableAccessorInfo> Factory::NewExecutableAccessorInfo() {
  Handle<ExecutableAccessorInfo> info =
      Handle<ExecutableAccessorInfo>::cast(
          NewStruct(EXECUTABLE_ACCESSOR_INFO_TYPE));
828 829 830 831 832 833
  info->set_flag(0);  // Must clear the flag, it was initialized as undefined.
  return info;
}


Handle<Script> Factory::NewScript(Handle<String> source) {
834
  // Create and initialize script object.
835
  Heap* heap = isolate()->heap();
836 837
  Handle<Script> script = Handle<Script>::cast(NewStruct(SCRIPT_TYPE));
  script->set_source(*source);
838
  script->set_name(heap->undefined_value());
839
  script->set_id(isolate()->heap()->NextScriptId());
840 841
  script->set_line_offset(Smi::FromInt(0));
  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 846
  script->set_line_ends(heap->undefined_value());
  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 852 853 854
  return script;
}


855
Handle<Foreign> Factory::NewForeign(Address addr, PretenureFlag pretenure) {
856
  CALL_HEAP_FUNCTION(isolate(),
857 858
                     isolate()->heap()->AllocateForeign(addr, pretenure),
                     Foreign);
859 860 861
}


862 863
Handle<Foreign> Factory::NewForeign(const AccessorDescriptor* desc) {
  return NewForeign((Address) desc, TENURED);
864 865 866
}


867
Handle<ByteArray> Factory::NewByteArray(int length, PretenureFlag pretenure) {
868
  DCHECK(0 <= length);
869 870 871 872
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateByteArray(length, pretenure),
      ByteArray);
873 874 875
}


876
Handle<BytecodeArray> Factory::NewBytecodeArray(int length,
877 878
                                                const byte* raw_bytecodes,
                                                int frame_size) {
879 880
  DCHECK(0 <= length);
  CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->AllocateBytecodeArray(
881
                                    length, raw_bytecodes, frame_size),
882 883 884 885
                     BytecodeArray);
}


886 887 888
Handle<FixedTypedArrayBase> Factory::NewFixedTypedArrayWithExternalPointer(
    int length, ExternalArrayType array_type, void* external_pointer,
    PretenureFlag pretenure) {
889
  DCHECK(0 <= length && length <= Smi::kMaxValue);
890
  CALL_HEAP_FUNCTION(
891 892 893
      isolate(), isolate()->heap()->AllocateFixedTypedArrayWithExternalPointer(
                     length, array_type, external_pointer, pretenure),
      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 902 903
  CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->AllocateFixedTypedArray(
                                    length, array_type, initialize, pretenure),
                     FixedTypedArrayBase);
904 905 906
}


907 908 909 910 911 912 913 914 915
Handle<Cell> Factory::NewCell(Handle<Object> value) {
  AllowDeferredHandleDereference convert_to_cell;
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateCell(*value),
      Cell);
}


916
Handle<PropertyCell> Factory::NewPropertyCell() {
917 918
  CALL_HEAP_FUNCTION(
      isolate(),
919
      isolate()->heap()->AllocatePropertyCell(),
920
      PropertyCell);
921 922 923
}


ulan@chromium.org's avatar
ulan@chromium.org committed
924
Handle<WeakCell> Factory::NewWeakCell(Handle<HeapObject> value) {
925 926
  // It is safe to dereference the value because we are embedding it
  // in cell and not inspecting its fields.
ulan@chromium.org's avatar
ulan@chromium.org committed
927 928 929 930 931 932
  AllowDeferredHandleDereference convert_to_cell;
  CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->AllocateWeakCell(*value),
                     WeakCell);
}


933
Handle<AllocationSite> Factory::NewAllocationSite() {
934
  Handle<Map> map = allocation_site_map();
935
  Handle<AllocationSite> site = New<AllocationSite>(map, OLD_SPACE);
936 937 938 939 940 941
  site->Initialize();

  // Link the site
  site->set_weak_next(isolate()->heap()->allocation_sites_list());
  isolate()->heap()->set_allocation_sites_list(*site);
  return site;
942 943 944
}


945 946 947
Handle<Map> Factory::NewMap(InstanceType type,
                            int instance_size,
                            ElementsKind elements_kind) {
948 949
  CALL_HEAP_FUNCTION(
      isolate(),
950
      isolate()->heap()->AllocateMap(type, instance_size, elements_kind),
951
      Map);
952 953 954
}


955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972
Handle<JSObject> Factory::CopyJSObject(Handle<JSObject> object) {
  CALL_HEAP_FUNCTION(isolate(),
                     isolate()->heap()->CopyJSObject(*object, NULL),
                     JSObject);
}


Handle<JSObject> Factory::CopyJSObjectWithAllocationSite(
    Handle<JSObject> object,
    Handle<AllocationSite> site) {
  CALL_HEAP_FUNCTION(isolate(),
                     isolate()->heap()->CopyJSObject(
                         *object,
                         site.is_null() ? NULL : *site),
                     JSObject);
}


973 974 975 976 977
Handle<FixedArray> Factory::CopyFixedArrayWithMap(Handle<FixedArray> array,
                                                  Handle<Map> map) {
  CALL_HEAP_FUNCTION(isolate(),
                     isolate()->heap()->CopyFixedArrayWithMap(*array, *map),
                     FixedArray);
978 979 980
}


981
Handle<FixedArray> Factory::CopyFixedArrayAndGrow(Handle<FixedArray> array,
982 983 984 985
                                                  int grow_by,
                                                  PretenureFlag pretenure) {
  CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->CopyFixedArrayAndGrow(
                                    *array, grow_by, pretenure),
986 987 988 989
                     FixedArray);
}


990
Handle<FixedArray> Factory::CopyFixedArray(Handle<FixedArray> array) {
991
  CALL_HEAP_FUNCTION(isolate(),
992
                     isolate()->heap()->CopyFixedArray(*array),
993 994 995 996
                     FixedArray);
}


997 998
Handle<FixedArray> Factory::CopyAndTenureFixedCOWArray(
    Handle<FixedArray> array) {
999
  DCHECK(isolate()->heap()->InNewSpace(*array));
1000
  CALL_HEAP_FUNCTION(isolate(),
1001
                     isolate()->heap()->CopyAndTenureFixedCOWArray(*array),
1002
                     FixedArray);
1003 1004 1005
}


1006 1007
Handle<FixedDoubleArray> Factory::CopyFixedDoubleArray(
    Handle<FixedDoubleArray> array) {
1008 1009 1010
  CALL_HEAP_FUNCTION(isolate(),
                     isolate()->heap()->CopyFixedDoubleArray(*array),
                     FixedDoubleArray);
1011 1012 1013
}


1014 1015
Handle<Object> Factory::NewNumber(double value,
                                  PretenureFlag pretenure) {
1016 1017 1018
  // We need to distinguish the minus zero value and this cannot be
  // done after conversion to int. Doing this by comparing bit
  // patterns is faster than using fpclassify() et al.
1019
  if (IsMinusZero(value)) return NewHeapNumber(-0.0, IMMUTABLE, pretenure);
1020

1021
  int int_value = FastD2IChecked(value);
1022 1023 1024 1025 1026
  if (value == int_value && Smi::IsValid(int_value)) {
    return handle(Smi::FromInt(int_value), isolate());
  }

  // Materialize the value in the heap.
1027
  return NewHeapNumber(value, IMMUTABLE, pretenure);
1028 1029 1030
}


1031 1032
Handle<Object> Factory::NewNumberFromInt(int32_t value,
                                         PretenureFlag pretenure) {
1033
  if (Smi::IsValid(value)) return handle(Smi::FromInt(value), isolate());
1034 1035
  // Bypass NewNumber to avoid various redundant checks.
  return NewHeapNumber(FastI2D(value), IMMUTABLE, pretenure);
1036 1037 1038
}


1039
Handle<Object> Factory::NewNumberFromUint(uint32_t value,
1040 1041 1042 1043 1044
                                          PretenureFlag pretenure) {
  int32_t int32v = static_cast<int32_t>(value);
  if (int32v >= 0 && Smi::IsValid(int32v)) {
    return handle(Smi::FromInt(int32v), isolate());
  }
1045
  return NewHeapNumber(FastUI2D(value), IMMUTABLE, pretenure);
1046 1047 1048
}


1049
Handle<HeapNumber> Factory::NewHeapNumber(double value,
1050
                                          MutableMode mode,
1051 1052 1053
                                          PretenureFlag pretenure) {
  CALL_HEAP_FUNCTION(
      isolate(),
1054 1055
      isolate()->heap()->AllocateHeapNumber(value, mode, pretenure),
      HeapNumber);
1056 1057 1058
}


1059
Handle<Float32x4> Factory::NewFloat32x4(float lanes[4],
1060
                                        PretenureFlag pretenure) {
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
  CALL_HEAP_FUNCTION(isolate(),
                     isolate()->heap()->AllocateFloat32x4(lanes, pretenure),
                     Float32x4);
}


Handle<Int32x4> Factory::NewInt32x4(int32_t lanes[4], PretenureFlag pretenure) {
  CALL_HEAP_FUNCTION(
      isolate(), isolate()->heap()->AllocateInt32x4(lanes, pretenure), Int32x4);
}


Handle<Bool32x4> Factory::NewBool32x4(bool lanes[4], PretenureFlag pretenure) {
  CALL_HEAP_FUNCTION(isolate(),
                     isolate()->heap()->AllocateBool32x4(lanes, pretenure),
                     Bool32x4);
}


Handle<Int16x8> Factory::NewInt16x8(int16_t lanes[8], PretenureFlag pretenure) {
1081
  CALL_HEAP_FUNCTION(
1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
      isolate(), isolate()->heap()->AllocateInt16x8(lanes, pretenure), Int16x8);
}


Handle<Bool16x8> Factory::NewBool16x8(bool lanes[8], PretenureFlag pretenure) {
  CALL_HEAP_FUNCTION(isolate(),
                     isolate()->heap()->AllocateBool16x8(lanes, pretenure),
                     Bool16x8);
}


Handle<Int8x16> Factory::NewInt8x16(int8_t lanes[16], PretenureFlag pretenure) {
  CALL_HEAP_FUNCTION(
      isolate(), isolate()->heap()->AllocateInt8x16(lanes, pretenure), Int8x16);
}


Handle<Bool8x16> Factory::NewBool8x16(bool lanes[16], PretenureFlag pretenure) {
  CALL_HEAP_FUNCTION(isolate(),
                     isolate()->heap()->AllocateBool8x16(lanes, pretenure),
                     Bool8x16);
1103 1104 1105
}


1106 1107 1108 1109 1110 1111
Handle<Object> Factory::NewError(const char* maker,
                                 MessageTemplate::Template template_index,
                                 Handle<Object> arg0, Handle<Object> arg1,
                                 Handle<Object> arg2) {
  HandleScope scope(isolate());
  Handle<String> error_maker = InternalizeUtf8String(maker);
1112 1113 1114 1115 1116 1117 1118
  if (isolate()->bootstrapper()->IsActive()) {
    // If this exception is being thrown during bootstrapping,
    // js_builtins_object is unavailable. We return the error maker
    // name's string as the exception since we have nothing better
    // to do.
    return scope.CloseAndEscape(error_maker);
  }
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
  Handle<Object> fun_obj = Object::GetProperty(isolate()->js_builtins_object(),
                                               error_maker).ToHandleChecked();

  Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
  Handle<Object> message_type(Smi::FromInt(template_index), isolate());
  if (arg0.is_null()) arg0 = undefined_value();
  if (arg1.is_null()) arg1 = undefined_value();
  if (arg2.is_null()) arg2 = undefined_value();
  Handle<Object> argv[] = {message_type, arg0, arg1, arg2};

  // Invoke the JavaScript factory method. If an exception is thrown while
  // running the factory method, use the exception as the result.
  Handle<Object> result;
  MaybeHandle<Object> exception;
  if (!Execution::TryCall(fun, isolate()->js_builtins_object(), arraysize(argv),
                          argv, &exception).ToHandle(&result)) {
    Handle<Object> exception_obj;
    if (exception.ToHandle(&exception_obj)) {
      result = exception_obj;
    } else {
      result = undefined_value();
    }
  }
  return scope.CloseAndEscape(result);
}


1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159
Handle<Object> Factory::NewError(MessageTemplate::Template template_index,
                                 Handle<Object> arg0, Handle<Object> arg1,
                                 Handle<Object> arg2) {
  return NewError("MakeError", template_index, arg0, arg1, arg2);
}


Handle<Object> Factory::NewTypeError(MessageTemplate::Template template_index,
                                     Handle<Object> arg0, Handle<Object> arg1,
                                     Handle<Object> arg2) {
  return NewError("MakeTypeError", template_index, arg0, arg1, arg2);
}


1160 1161 1162 1163 1164 1165 1166
Handle<Object> Factory::NewSyntaxError(MessageTemplate::Template template_index,
                                       Handle<Object> arg0, Handle<Object> arg1,
                                       Handle<Object> arg2) {
  return NewError("MakeSyntaxError", template_index, arg0, arg1, arg2);
}


1167 1168 1169 1170 1171 1172 1173
Handle<Object> Factory::NewReferenceError(
    MessageTemplate::Template template_index, Handle<Object> arg0,
    Handle<Object> arg1, Handle<Object> arg2) {
  return NewError("MakeReferenceError", template_index, arg0, arg1, arg2);
}


1174 1175 1176 1177 1178 1179 1180
Handle<Object> Factory::NewRangeError(MessageTemplate::Template template_index,
                                      Handle<Object> arg0, Handle<Object> arg1,
                                      Handle<Object> arg2) {
  return NewError("MakeRangeError", template_index, arg0, arg1, arg2);
}


1181 1182 1183 1184
Handle<Object> Factory::NewEvalError(MessageTemplate::Template template_index,
                                     Handle<Object> arg0, Handle<Object> arg1,
                                     Handle<Object> arg2) {
  return NewError("MakeEvalError", template_index, arg0, arg1, arg2);
1185 1186 1187
}


1188
Handle<String> Factory::EmergencyNewError(const char* message,
1189 1190 1191 1192 1193 1194 1195
                                          Handle<JSArray> args) {
  const int kBufferSize = 1000;
  char buffer[kBufferSize];
  size_t space = kBufferSize;
  char* p = &buffer[0];

  Vector<char> v(buffer, kBufferSize);
1196
  StrNCpy(v, message, space);
1197
  space -= Min(space, strlen(message));
1198 1199
  p = &buffer[kBufferSize] - space;

1200
  for (int i = 0; i < Smi::cast(args->length())->value(); i++) {
1201 1202 1203 1204
    if (space > 0) {
      *p++ = ' ';
      space--;
      if (space > 0) {
1205
        Handle<String> arg_str = Handle<String>::cast(
1206
            Object::GetElement(isolate(), args, i).ToHandleChecked());
rmcilroy's avatar
rmcilroy committed
1207
        base::SmartArrayPointer<char> arg = arg_str->ToCString();
1208
        Vector<char> v2(p, static_cast<int>(space));
1209
        StrNCpy(v2, arg.get(), space);
1210
        space -= Min(space, strlen(arg.get()));
1211 1212 1213 1214 1215 1216 1217 1218 1219
        p = &buffer[kBufferSize] - space;
      }
    }
  }
  if (space > 0) {
    *p = '\0';
  } else {
    buffer[kBufferSize - 1] = '\0';
  }
1220
  return NewStringFromUtf8(CStrVector(buffer), TENURED).ToHandleChecked();
1221 1222 1223
}


1224 1225
Handle<Object> Factory::NewError(const char* maker, const char* message,
                                 Handle<JSArray> args) {
1226
  Handle<String> make_str = InternalizeUtf8String(maker);
1227 1228
  Handle<Object> fun_obj = Object::GetProperty(
      isolate()->js_builtins_object(), make_str).ToHandleChecked();
1229 1230
  // If the builtins haven't been properly configured yet this error
  // constructor may not have been defined.  Bail out.
1231
  if (!fun_obj->IsJSFunction()) {
1232
    return EmergencyNewError(message, args);
1233
  }
1234
  Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
1235 1236
  Handle<Object> message_obj = InternalizeUtf8String(message);
  Handle<Object> argv[] = { message_obj, args };
1237 1238 1239

  // Invoke the JavaScript factory method. If an exception is thrown while
  // running the factory method, use the exception as the result.
1240
  Handle<Object> result;
1241
  MaybeHandle<Object> exception;
1242 1243
  if (!Execution::TryCall(fun,
                          isolate()->js_builtins_object(),
1244
                          arraysize(argv),
1245 1246
                          argv,
                          &exception).ToHandle(&result)) {
1247 1248 1249
    Handle<Object> exception_obj;
    if (exception.ToHandle(&exception_obj)) return exception_obj;
    return undefined_value();
1250
  }
1251 1252 1253 1254
  return result;
}


1255 1256
Handle<Object> Factory::NewError(const char* constructor,
                                 Handle<String> message) {
1257
  Handle<String> constr = InternalizeUtf8String(constructor);
1258 1259
  Handle<JSFunction> fun = Handle<JSFunction>::cast(Object::GetProperty(
      isolate()->js_builtins_object(), constr).ToHandleChecked());
1260
  Handle<Object> argv[] = { message };
1261 1262 1263

  // Invoke the JavaScript factory method. If an exception is thrown while
  // running the factory method, use the exception as the result.
1264
  Handle<Object> result;
1265
  MaybeHandle<Object> exception;
1266 1267
  if (!Execution::TryCall(fun,
                          isolate()->js_builtins_object(),
1268
                          arraysize(argv),
1269 1270
                          argv,
                          &exception).ToHandle(&result)) {
1271 1272 1273
    Handle<Object> exception_obj;
    if (exception.ToHandle(&exception_obj)) return exception_obj;
    return undefined_value();
1274
  }
1275 1276 1277 1278
  return result;
}


1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
void Factory::InitializeFunction(Handle<JSFunction> function,
                                 Handle<SharedFunctionInfo> info,
                                 Handle<Context> context) {
  function->initialize_properties();
  function->initialize_elements();
  function->set_shared(*info);
  function->set_code(info->code());
  function->set_context(*context);
  function->set_prototype_or_initial_map(*the_hole_value());
  function->set_literals_or_bindings(*empty_fixed_array());
1289
  function->set_next_function_link(*undefined_value(), SKIP_WRITE_BARRIER);
1290 1291 1292 1293 1294 1295 1296
}


Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
                                        Handle<SharedFunctionInfo> info,
                                        Handle<Context> context,
                                        PretenureFlag pretenure) {
1297
  AllocationSpace space = pretenure == TENURED ? OLD_SPACE : NEW_SPACE;
1298 1299 1300 1301 1302 1303
  Handle<JSFunction> result = New<JSFunction>(map, space);
  InitializeFunction(result, info, context);
  return result;
}


1304 1305 1306
Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
                                        Handle<String> name,
                                        MaybeHandle<Code> code) {
1307
  Handle<Context> context(isolate()->native_context());
1308
  Handle<SharedFunctionInfo> info = NewSharedFunctionInfo(name, code);
1309
  DCHECK(is_sloppy(info->language_mode()) &&
1310 1311
         (map.is_identical_to(isolate()->sloppy_function_map()) ||
          map.is_identical_to(
1312 1313
              isolate()->sloppy_function_without_prototype_map()) ||
          map.is_identical_to(
1314 1315
              isolate()->sloppy_function_with_readonly_prototype_map()) ||
          map.is_identical_to(isolate()->strict_function_map())));
1316
  return NewFunction(map, info, context);
1317 1318 1319
}


1320
Handle<JSFunction> Factory::NewFunction(Handle<String> name) {
1321 1322
  return NewFunction(
      isolate()->sloppy_function_map(), name, MaybeHandle<Code>());
1323 1324 1325
}


1326
Handle<JSFunction> Factory::NewFunctionWithoutPrototype(Handle<String> name,
1327 1328 1329 1330 1331 1332
                                                        Handle<Code> code,
                                                        bool is_strict) {
  Handle<Map> map = is_strict
                        ? isolate()->strict_function_without_prototype_map()
                        : isolate()->sloppy_function_without_prototype_map();
  return NewFunction(map, name, code);
1333 1334 1335
}


1336
Handle<JSFunction> Factory::NewFunction(Handle<String> name, Handle<Code> code,
1337
                                        Handle<Object> prototype,
1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
                                        bool read_only_prototype,
                                        bool is_strict) {
  // In strict mode, readonly strict map is only available during bootstrap
  DCHECK(!is_strict || !read_only_prototype ||
         isolate()->bootstrapper()->IsActive());
  Handle<Map> map =
      is_strict ? isolate()->strict_function_map()
                : read_only_prototype
                      ? isolate()->sloppy_function_with_readonly_prototype_map()
                      : isolate()->sloppy_function_map();
1348
  Handle<JSFunction> result = NewFunction(map, name, code);
1349 1350 1351 1352 1353
  result->set_prototype_or_initial_map(*prototype);
  return result;
}


1354
Handle<JSFunction> Factory::NewFunction(Handle<String> name, Handle<Code> code,
1355
                                        Handle<Object> prototype,
1356 1357
                                        InstanceType type, int instance_size,
                                        bool read_only_prototype,
1358 1359
                                        bool install_constructor,
                                        bool is_strict) {
1360
  // Allocate the function
1361 1362
  Handle<JSFunction> function =
      NewFunction(name, code, prototype, read_only_prototype, is_strict);
1363

1364 1365 1366
  ElementsKind elements_kind =
      type == JS_ARRAY_TYPE ? FAST_SMI_ELEMENTS : FAST_HOLEY_SMI_ELEMENTS;
  Handle<Map> initial_map = NewMap(type, instance_size, elements_kind);
1367 1368 1369 1370 1371 1372 1373
  if (!function->shared()->is_generator()) {
    if (prototype->IsTheHole()) {
      prototype = NewFunctionPrototype(function);
    } else if (install_constructor) {
      JSObject::AddProperty(Handle<JSObject>::cast(prototype),
                            constructor_string(), function, DONT_ENUM);
    }
1374
  }
1375

1376 1377
  JSFunction::SetInitialMap(function, initial_map,
                            Handle<JSReceiver>::cast(prototype));
1378 1379 1380 1381 1382

  return function;
}


1383
Handle<JSFunction> Factory::NewFunction(Handle<String> name,
1384
                                        Handle<Code> code,
1385
                                        InstanceType type,
1386 1387
                                        int instance_size) {
  return NewFunction(name, code, the_hole_value(), type, instance_size);
1388 1389 1390
}


1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403
Handle<JSObject> Factory::NewFunctionPrototype(Handle<JSFunction> function) {
  // Make sure to use globals from the function's context, since the function
  // can be from a different context.
  Handle<Context> native_context(function->context()->native_context());
  Handle<Map> new_map;
  if (function->shared()->is_generator()) {
    // Generator prototypes can share maps since they don't have "constructor"
    // properties.
    new_map = handle(native_context->generator_object_prototype_map());
  } else {
    // Each function prototype gets a fresh map to avoid unwanted sharing of
    // maps between prototypes of different constructors.
    Handle<JSFunction> object_function(native_context->object_function());
1404
    DCHECK(object_function->has_initial_map());
1405
    new_map = handle(object_function->initial_map());
1406 1407
  }

1408
  DCHECK(!new_map->is_prototype_map());
1409 1410 1411
  Handle<JSObject> prototype = NewJSObjectFromMap(new_map);

  if (!function->shared()->is_generator()) {
1412
    JSObject::AddProperty(prototype, constructor_string(), function, DONT_ENUM);
1413 1414 1415 1416 1417 1418 1419 1420 1421 1422
  }

  return prototype;
}


Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
    Handle<SharedFunctionInfo> info,
    Handle<Context> context,
    PretenureFlag pretenure) {
1423 1424
  int map_index =
      Context::FunctionMapIndex(info->language_mode(), info->kind());
1425 1426 1427 1428 1429 1430 1431
  Handle<Map> map(Map::cast(context->native_context()->get(map_index)));
  Handle<JSFunction> result = NewFunction(map, info, context, pretenure);

  if (info->ic_age() != isolate()->heap()->global_ic_age()) {
    info->ResetForNewContext(isolate()->heap()->global_ic_age());
  }

1432 1433 1434 1435
  if (FLAG_always_opt && info->allows_lazy_compilation()) {
    result->MarkForOptimization();
  }

1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446
  CodeAndLiterals cached = info->SearchOptimizedCodeMap(
      context->native_context(), BailoutId::None());
  if (cached.code != nullptr) {
    // Caching of optimized code enabled and optimized code found.
    if (cached.literals != nullptr) result->set_literals(cached.literals);
    DCHECK(!cached.code->marked_for_deoptimization());
    DCHECK(result->shared()->is_compiled());
    result->ReplaceCode(cached.code);
  }

  if (cached.literals == nullptr && !info->bound()) {
1447
    int number_of_literals = info->num_literals();
1448
    // TODO(mstarzinger): Consider sharing the newly created literals array.
1449 1450 1451 1452 1453 1454 1455 1456
    Handle<FixedArray> literals = NewFixedArray(number_of_literals, pretenure);
    result->set_literals(*literals);
  }

  return result;
}


1457
Handle<ScopeInfo> Factory::NewScopeInfo(int length) {
1458 1459 1460 1461
  Handle<FixedArray> array = NewFixedArray(length, TENURED);
  array->set_map_no_write_barrier(*scope_info_map());
  Handle<ScopeInfo> scope_info = Handle<ScopeInfo>::cast(array);
  return scope_info;
1462 1463 1464
}


1465
Handle<JSObject> Factory::NewExternal(void* value) {
1466 1467 1468 1469
  Handle<Foreign> foreign = NewForeign(static_cast<Address>(value));
  Handle<JSObject> external = NewJSObjectFromMap(external_map());
  external->SetInternalField(0, *foreign);
  return external;
1470 1471 1472
}


1473 1474 1475
Handle<Code> Factory::NewCodeRaw(int object_size, bool immovable) {
  CALL_HEAP_FUNCTION(isolate(),
                     isolate()->heap()->AllocateCode(object_size, immovable),
1476 1477 1478 1479
                     Code);
}


1480 1481
Handle<Code> Factory::NewCode(const CodeDesc& desc,
                              Code::Flags flags,
1482
                              Handle<Object> self_ref,
1483
                              bool immovable,
1484
                              bool crankshafted,
1485 1486
                              int prologue_offset,
                              bool is_debug) {
1487 1488 1489 1490 1491 1492
  Handle<ByteArray> reloc_info = NewByteArray(desc.reloc_size, TENURED);

  // Compute size.
  int body_size = RoundUp(desc.instr_size, kObjectAlignment);
  int obj_size = Code::SizeFor(body_size);

1493
  Handle<Code> code = NewCodeRaw(obj_size, immovable);
1494 1495 1496
  DCHECK(isolate()->code_range() == NULL || !isolate()->code_range()->valid() ||
         isolate()->code_range()->contains(code->address()) ||
         obj_size <= isolate()->heap()->code_space()->AreaSize());
1497 1498 1499 1500 1501

  // The code object has not been fully initialized yet.  We rely on the
  // fact that no allocation will happen from this point on.
  DisallowHeapAllocation no_gc;
  code->set_gc_metadata(Smi::FromInt(0));
1502
  code->set_ic_age(isolate()->heap()->global_ic_age());
1503 1504 1505 1506 1507 1508 1509
  code->set_instruction_size(desc.instr_size);
  code->set_relocation_info(*reloc_info);
  code->set_flags(flags);
  code->set_raw_kind_specific_flags1(0);
  code->set_raw_kind_specific_flags2(0);
  code->set_is_crankshafted(crankshafted);
  code->set_deoptimization_data(*empty_fixed_array(), SKIP_WRITE_BARRIER);
1510
  code->set_raw_type_feedback_info(Smi::FromInt(0));
1511 1512 1513
  code->set_next_code_link(*undefined_value());
  code->set_handler_table(*empty_fixed_array(), SKIP_WRITE_BARRIER);
  code->set_prologue_offset(prologue_offset);
1514 1515 1516
  if (FLAG_enable_embedded_constant_pool) {
    code->set_constant_pool_offset(desc.instr_size - desc.constant_pool_size);
  }
1517 1518 1519 1520
  if (code->kind() == Code::OPTIMIZED_FUNCTION) {
    code->set_marked_for_deoptimization(false);
  }

1521
  if (is_debug) {
1522
    DCHECK(code->kind() == Code::FUNCTION);
1523 1524 1525
    code->set_has_debug_break_slots(true);
  }

1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537
  // Allow self references to created code object by patching the handle to
  // point to the newly allocated Code object.
  if (!self_ref.is_null()) *(self_ref.location()) = *code;

  // Migrate generated code.
  // The generated code can contain Object** values (typically from handles)
  // that are dereferenced during the copy to point directly to the actual heap
  // objects. These pointers can include references to the code object itself,
  // through the self_reference parameter.
  code->CopyFrom(desc);

#ifdef VERIFY_HEAP
1538
  if (FLAG_verify_heap) code->ObjectVerify();
1539 1540
#endif
  return code;
1541 1542 1543 1544
}


Handle<Code> Factory::CopyCode(Handle<Code> code) {
1545 1546 1547
  CALL_HEAP_FUNCTION(isolate(),
                     isolate()->heap()->CopyCode(*code),
                     Code);
1548 1549 1550
}


1551
Handle<Code> Factory::CopyCode(Handle<Code> code, Vector<byte> reloc_info) {
1552 1553 1554
  CALL_HEAP_FUNCTION(isolate(),
                     isolate()->heap()->CopyCode(*code, reloc_info),
                     Code);
1555 1556 1557
}


1558 1559
Handle<JSObject> Factory::NewJSObject(Handle<JSFunction> constructor,
                                      PretenureFlag pretenure) {
1560
  JSFunction::EnsureHasInitialMap(constructor);
1561 1562 1563
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateJSObject(*constructor, pretenure), JSObject);
1564 1565 1566
}


1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577
Handle<JSObject> Factory::NewJSObjectWithMemento(
    Handle<JSFunction> constructor,
    Handle<AllocationSite> site) {
  JSFunction::EnsureHasInitialMap(constructor);
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateJSObject(*constructor, NOT_TENURED, *site),
      JSObject);
}


1578 1579
Handle<JSModule> Factory::NewJSModule(Handle<Context> context,
                                      Handle<ScopeInfo> scope_info) {
1580 1581 1582 1583 1584 1585 1586 1587
  // Allocate a fresh map. Modules do not have a prototype.
  Handle<Map> map = NewMap(JS_MODULE_TYPE, JSModule::kSize);
  // Allocate the object based on the map.
  Handle<JSModule> module =
      Handle<JSModule>::cast(NewJSObjectFromMap(map, TENURED));
  module->set_context(*context);
  module->set_scope_info(*scope_info);
  return module;
1588 1589 1590
}


1591
Handle<GlobalObject> Factory::NewGlobalObject(Handle<JSFunction> constructor) {
1592
  DCHECK(constructor->has_initial_map());
1593
  Handle<Map> map(constructor->initial_map());
1594
  DCHECK(map->is_dictionary_map());
1595 1596 1597 1598

  // Make sure no field properties are described in the initial map.
  // This guarantees us that normalizing the properties does not
  // require us to change property values to PropertyCells.
1599
  DCHECK(map->NextFreePropertyIndex() == 0);
1600 1601 1602

  // Make sure we don't have a ton of pre-allocated slots in the
  // global objects. They will be unused once we normalize the object.
1603 1604
  DCHECK(map->unused_property_fields() == 0);
  DCHECK(map->inobject_properties() == 0);
1605 1606 1607 1608 1609 1610 1611 1612

  // Initial size of the backing store to avoid resize of the storage during
  // bootstrapping. The size differs between the JS global object ad the
  // builtins object.
  int initial_size = map->instance_type() == JS_GLOBAL_OBJECT_TYPE ? 64 : 512;

  // Allocate a dictionary object for backing storage.
  int at_least_space_for = map->NumberOfOwnDescriptors() * 2 + initial_size;
1613 1614
  Handle<GlobalDictionary> dictionary =
      GlobalDictionary::New(isolate(), at_least_space_for);
1615 1616 1617 1618 1619 1620

  // The global object might be created from an object template with accessors.
  // Fill these accessors into the dictionary.
  Handle<DescriptorArray> descs(map->instance_descriptors());
  for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {
    PropertyDetails details = descs->GetDetails(i);
1621 1622
    // Only accessors are expected.
    DCHECK_EQ(ACCESSOR_CONSTANT, details.type());
1623 1624
    PropertyDetails d(details.attributes(), ACCESSOR_CONSTANT, i + 1,
                      PropertyCellType::kMutable);
1625
    Handle<Name> name(descs->GetKey(i));
1626 1627
    Handle<PropertyCell> cell = NewPropertyCell();
    cell->set_value(descs->GetCallbacksObject(i));
1628
    // |dictionary| already contains enough space for all properties.
1629
    USE(GlobalDictionary::Add(dictionary, name, cell, d));
1630 1631 1632
  }

  // Allocate the global object and initialize it with the backing store.
1633
  Handle<GlobalObject> global = New<GlobalObject>(map, OLD_SPACE);
1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
  isolate()->heap()->InitializeJSObjectFromMap(*global, *dictionary, *map);

  // Create a new map for the global object.
  Handle<Map> new_map = Map::CopyDropDescriptors(map);
  new_map->set_dictionary_map(true);

  // Set up the global object as a normalized object.
  global->set_map(*new_map);
  global->set_properties(*dictionary);

  // Make sure result is a global object with properties in dictionary.
1645
  DCHECK(global->IsGlobalObject() && !global->HasFastProperties());
1646 1647 1648
  return global;
}

1649

1650 1651 1652 1653
Handle<JSObject> Factory::NewJSObjectFromMap(
    Handle<Map> map,
    PretenureFlag pretenure,
    Handle<AllocationSite> allocation_site) {
1654 1655
  CALL_HEAP_FUNCTION(
      isolate(),
1656 1657 1658 1659
      isolate()->heap()->AllocateJSObjectFromMap(
          *map,
          pretenure,
          allocation_site.is_null() ? NULL : *allocation_site),
1660
      JSObject);
1661 1662 1663
}


1664
Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind,
1665
                                    Strength strength,
1666
                                    PretenureFlag pretenure) {
1667 1668
  Map* map = isolate()->get_initial_js_array_map(elements_kind, strength);
  if (map == nullptr) {
1669
    DCHECK(strength == Strength::WEAK);
1670 1671 1672 1673
    Context* native_context = isolate()->context()->native_context();
    JSFunction* array_function = native_context->array_function();
    map = array_function->initial_map();
  }
1674
  return Handle<JSArray>::cast(NewJSObjectFromMap(handle(map), pretenure));
1675 1676 1677
}


1678
Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind, int length,
1679
                                    int capacity, Strength strength,
1680
                                    ArrayStorageAllocationMode mode,
1681
                                    PretenureFlag pretenure) {
1682
  Handle<JSArray> array = NewJSArray(elements_kind, strength, pretenure);
1683 1684
  NewJSArrayStorage(array, length, capacity, mode);
  return array;
1685 1686 1687
}


1688
Handle<JSArray> Factory::NewJSArrayWithElements(Handle<FixedArrayBase> elements,
1689
                                                ElementsKind elements_kind,
1690
                                                int length, Strength strength,
1691
                                                PretenureFlag pretenure) {
1692
  DCHECK(length <= elements->length());
1693
  Handle<JSArray> array = NewJSArray(elements_kind, strength, pretenure);
1694 1695 1696 1697 1698

  array->set_elements(*elements);
  array->set_length(Smi::FromInt(length));
  JSObject::ValidateElements(array);
  return array;
1699 1700 1701
}


1702
void Factory::NewJSArrayStorage(Handle<JSArray> array,
1703 1704 1705
                                int length,
                                int capacity,
                                ArrayStorageAllocationMode mode) {
1706
  DCHECK(capacity >= length);
1707 1708 1709 1710 1711 1712 1713

  if (capacity == 0) {
    array->set_length(Smi::FromInt(0));
    array->set_elements(*empty_fixed_array());
    return;
  }

1714
  HandleScope inner_scope(isolate());
1715 1716 1717 1718 1719 1720
  Handle<FixedArrayBase> elms;
  ElementsKind elements_kind = array->GetElementsKind();
  if (IsFastDoubleElementsKind(elements_kind)) {
    if (mode == DONT_INITIALIZE_ARRAY_ELEMENTS) {
      elms = NewFixedDoubleArray(capacity);
    } else {
1721
      DCHECK(mode == INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
1722 1723 1724
      elms = NewFixedDoubleArrayWithHoles(capacity);
    }
  } else {
1725
    DCHECK(IsFastSmiOrObjectElementsKind(elements_kind));
1726 1727 1728
    if (mode == DONT_INITIALIZE_ARRAY_ELEMENTS) {
      elms = NewUninitializedFixedArray(capacity);
    } else {
1729
      DCHECK(mode == INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
1730 1731 1732 1733 1734 1735
      elms = NewFixedArrayWithHoles(capacity);
    }
  }

  array->set_elements(*elms);
  array->set_length(Smi::FromInt(length));
1736 1737 1738
}


1739 1740
Handle<JSGeneratorObject> Factory::NewJSGeneratorObject(
    Handle<JSFunction> function) {
1741
  DCHECK(function->shared()->is_generator());
1742 1743
  JSFunction::EnsureHasInitialMap(function);
  Handle<Map> map(function->initial_map());
1744
  DCHECK(map->instance_type() == JS_GENERATOR_OBJECT_TYPE);
1745 1746 1747 1748
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateJSObjectFromMap(*map),
      JSGeneratorObject);
1749 1750 1751
}


binji's avatar
binji committed
1752
Handle<JSArrayBuffer> Factory::NewJSArrayBuffer(SharedFlag shared) {
1753
  Handle<JSFunction> array_buffer_fun(
binji's avatar
binji committed
1754 1755 1756
      shared == SharedFlag::kShared
          ? isolate()->native_context()->shared_array_buffer_fun()
          : isolate()->native_context()->array_buffer_fun());
1757 1758 1759 1760
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateJSObject(*array_buffer_fun),
      JSArrayBuffer);
1761 1762 1763
}


1764
Handle<JSDataView> Factory::NewJSDataView() {
1765
  Handle<JSFunction> data_view_fun(
1766
      isolate()->native_context()->data_view_fun());
1767 1768 1769 1770
  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateJSObject(*data_view_fun),
      JSDataView);
1771 1772 1773
}


1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789
Handle<JSMap> Factory::NewJSMap() {
  Handle<Map> map(isolate()->native_context()->js_map_map());
  Handle<JSMap> js_map = Handle<JSMap>::cast(NewJSObjectFromMap(map));
  Runtime::JSMapInitialize(isolate(), js_map);
  return js_map;
}


Handle<JSSet> Factory::NewJSSet() {
  Handle<Map> map(isolate()->native_context()->js_set_map());
  Handle<JSSet> js_set = Handle<JSSet>::cast(NewJSObjectFromMap(map));
  Runtime::JSSetInitialize(isolate(), js_set);
  return js_set;
}


1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805
Handle<JSMapIterator> Factory::NewJSMapIterator() {
  Handle<Map> map(isolate()->native_context()->map_iterator_map());
  CALL_HEAP_FUNCTION(isolate(),
                     isolate()->heap()->AllocateJSObjectFromMap(*map),
                     JSMapIterator);
}


Handle<JSSetIterator> Factory::NewJSSetIterator() {
  Handle<Map> map(isolate()->native_context()->set_iterator_map());
  CALL_HEAP_FUNCTION(isolate(),
                     isolate()->heap()->AllocateJSObjectFromMap(*map),
                     JSSetIterator);
}


1806 1807 1808 1809 1810 1811
namespace {

ElementsKind GetExternalArrayElementsKind(ExternalArrayType type) {
  switch (type) {
#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
  case kExternal##Type##Array:                          \
1812
    return TYPE##_ELEMENTS;
1813 1814 1815
    TYPED_ARRAYS(TYPED_ARRAY_CASE)
  }
  UNREACHABLE();
1816
  return FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND;
1817 1818 1819 1820
#undef TYPED_ARRAY_CASE
}


1821 1822 1823 1824 1825 1826
size_t GetExternalArrayElementSize(ExternalArrayType type) {
  switch (type) {
#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
  case kExternal##Type##Array:                          \
    return size;
    TYPED_ARRAYS(TYPED_ARRAY_CASE)
1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857
    default:
      UNREACHABLE();
      return 0;
  }
#undef TYPED_ARRAY_CASE
}


size_t GetFixedTypedArraysElementSize(ElementsKind kind) {
  switch (kind) {
#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
  case TYPE##_ELEMENTS:                                 \
    return size;
    TYPED_ARRAYS(TYPED_ARRAY_CASE)
    default:
      UNREACHABLE();
      return 0;
  }
#undef TYPED_ARRAY_CASE
}


ExternalArrayType GetArrayTypeFromElementsKind(ElementsKind kind) {
  switch (kind) {
#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
  case TYPE##_ELEMENTS:                                 \
    return kExternal##Type##Array;
    TYPED_ARRAYS(TYPED_ARRAY_CASE)
    default:
      UNREACHABLE();
      return kExternalInt8Array;
1858 1859 1860 1861 1862
  }
#undef TYPED_ARRAY_CASE
}


1863
JSFunction* GetTypedArrayFun(ExternalArrayType type, Isolate* isolate) {
1864
  Context* native_context = isolate->context()->native_context();
1865
  switch (type) {
1866 1867 1868
#define TYPED_ARRAY_FUN(Type, type, TYPE, ctype, size)                        \
    case kExternal##Type##Array:                                              \
      return native_context->type##_array_fun();
1869

1870 1871
    TYPED_ARRAYS(TYPED_ARRAY_FUN)
#undef TYPED_ARRAY_FUN
1872

1873 1874
    default:
      UNREACHABLE();
1875
      return NULL;
1876
  }
1877 1878
}

1879

1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896
JSFunction* GetTypedArrayFun(ElementsKind elements_kind, Isolate* isolate) {
  Context* native_context = isolate->context()->native_context();
  switch (elements_kind) {
#define TYPED_ARRAY_FUN(Type, type, TYPE, ctype, size) \
  case TYPE##_ELEMENTS:                                \
    return native_context->type##_array_fun();

    TYPED_ARRAYS(TYPED_ARRAY_FUN)
#undef TYPED_ARRAY_FUN

    default:
      UNREACHABLE();
      return NULL;
  }
}


1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915
void SetupArrayBufferView(i::Isolate* isolate,
                          i::Handle<i::JSArrayBufferView> obj,
                          i::Handle<i::JSArrayBuffer> buffer,
                          size_t byte_offset, size_t byte_length) {
  DCHECK(byte_offset + byte_length <=
         static_cast<size_t>(buffer->byte_length()->Number()));

  obj->set_buffer(*buffer);

  i::Handle<i::Object> byte_offset_object =
      isolate->factory()->NewNumberFromSize(byte_offset);
  obj->set_byte_offset(*byte_offset_object);

  i::Handle<i::Object> byte_length_object =
      isolate->factory()->NewNumberFromSize(byte_length);
  obj->set_byte_length(*byte_length_object);
}


1916 1917
}  // namespace

1918 1919 1920

Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type) {
  Handle<JSFunction> typed_array_fun_handle(GetTypedArrayFun(type, isolate()));
1921 1922 1923 1924 1925

  CALL_HEAP_FUNCTION(
      isolate(),
      isolate()->heap()->AllocateJSObject(*typed_array_fun_handle),
      JSTypedArray);
1926 1927 1928
}


1929 1930 1931 1932 1933 1934 1935 1936 1937 1938
Handle<JSTypedArray> Factory::NewJSTypedArray(ElementsKind elements_kind) {
  Handle<JSFunction> typed_array_fun_handle(
      GetTypedArrayFun(elements_kind, isolate()));

  CALL_HEAP_FUNCTION(
      isolate(), isolate()->heap()->AllocateJSObject(*typed_array_fun_handle),
      JSTypedArray);
}


1939 1940
Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type,
                                              Handle<JSArrayBuffer> buffer,
1941
                                              size_t byte_offset,
1942
                                              size_t length) {
1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957
  Handle<JSTypedArray> obj = NewJSTypedArray(type);

  size_t element_size = GetExternalArrayElementSize(type);
  ElementsKind elements_kind = GetExternalArrayElementsKind(type);

  CHECK(byte_offset % element_size == 0);

  CHECK(length <= (std::numeric_limits<size_t>::max() / element_size));
  CHECK(length <= static_cast<size_t>(Smi::kMaxValue));
  size_t byte_length = length * element_size;
  SetupArrayBufferView(isolate(), obj, buffer, byte_offset, byte_length);

  Handle<Object> length_object = NewNumberFromSize(length);
  obj->set_length(*length_object);

1958
  Handle<FixedTypedArrayBase> elements = NewFixedTypedArrayWithExternalPointer(
1959 1960 1961 1962 1963 1964 1965 1966
      static_cast<int>(length), type,
      static_cast<uint8_t*>(buffer->backing_store()) + byte_offset);
  Handle<Map> map = JSObject::GetElementsTransitionMap(obj, elements_kind);
  JSObject::SetMapAndElements(obj, map, elements);
  return obj;
}


1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985
Handle<JSTypedArray> Factory::NewJSTypedArray(ElementsKind elements_kind,
                                              size_t number_of_elements) {
  Handle<JSTypedArray> obj = NewJSTypedArray(elements_kind);

  size_t element_size = GetFixedTypedArraysElementSize(elements_kind);
  ExternalArrayType array_type = GetArrayTypeFromElementsKind(elements_kind);

  CHECK(number_of_elements <=
        (std::numeric_limits<size_t>::max() / element_size));
  CHECK(number_of_elements <= static_cast<size_t>(Smi::kMaxValue));
  size_t byte_length = number_of_elements * element_size;

  obj->set_byte_offset(Smi::FromInt(0));
  i::Handle<i::Object> byte_length_object =
      isolate()->factory()->NewNumberFromSize(byte_length);
  obj->set_byte_length(*byte_length_object);
  Handle<Object> length_object = NewNumberFromSize(number_of_elements);
  obj->set_length(*length_object);

1986
  Handle<JSArrayBuffer> buffer = isolate()->factory()->NewJSArrayBuffer();
binji's avatar
binji committed
1987 1988
  Runtime::SetupArrayBuffer(isolate(), buffer, true, NULL, byte_length,
                            SharedFlag::kNotShared);
1989
  obj->set_buffer(*buffer);
1990 1991
  Handle<FixedTypedArrayBase> elements =
      isolate()->factory()->NewFixedTypedArray(
1992
          static_cast<int>(number_of_elements), array_type, true);
1993 1994 1995 1996 1997
  obj->set_elements(*elements);
  return obj;
}


1998 1999 2000 2001 2002 2003
Handle<JSDataView> Factory::NewJSDataView(Handle<JSArrayBuffer> buffer,
                                          size_t byte_offset,
                                          size_t byte_length) {
  Handle<JSDataView> obj = NewJSDataView();
  SetupArrayBufferView(isolate(), obj, buffer, byte_offset, byte_length);
  return obj;
2004 2005 2006
}


2007 2008
Handle<JSProxy> Factory::NewJSProxy(Handle<Object> handler,
                                    Handle<Object> prototype) {
2009 2010 2011 2012
  // Allocate map.
  // TODO(rossberg): Once we optimize proxies, think about a scheme to share
  // maps. Will probably depend on the identity of the handler object, too.
  Handle<Map> map = NewMap(JS_PROXY_TYPE, JSProxy::kSize);
2013
  Map::SetPrototype(map, prototype);
2014 2015 2016 2017 2018 2019 2020

  // Allocate the proxy object.
  Handle<JSProxy> result = New<JSProxy>(map, NEW_SPACE);
  result->InitializeBody(map->instance_size(), Smi::FromInt(0));
  result->set_handler(*handler);
  result->set_hash(*undefined_value(), SKIP_WRITE_BARRIER);
  return result;
2021 2022 2023
}


2024 2025 2026 2027
Handle<JSProxy> Factory::NewJSFunctionProxy(Handle<Object> handler,
                                            Handle<Object> call_trap,
                                            Handle<Object> construct_trap,
                                            Handle<Object> prototype) {
2028 2029 2030 2031
  // Allocate map.
  // TODO(rossberg): Once we optimize proxies, think about a scheme to share
  // maps. Will probably depend on the identity of the handler object, too.
  Handle<Map> map = NewMap(JS_FUNCTION_PROXY_TYPE, JSFunctionProxy::kSize);
2032
  Map::SetPrototype(map, prototype);
2033 2034 2035 2036 2037 2038 2039 2040 2041

  // Allocate the proxy object.
  Handle<JSFunctionProxy> result = New<JSFunctionProxy>(map, NEW_SPACE);
  result->InitializeBody(map->instance_size(), Smi::FromInt(0));
  result->set_handler(*handler);
  result->set_hash(*undefined_value(), SKIP_WRITE_BARRIER);
  result->set_call_trap(*call_trap);
  result->set_construct_trap(*construct_trap);
  return result;
2042 2043 2044
}


2045 2046 2047
void Factory::ReinitializeJSProxy(Handle<JSProxy> proxy, InstanceType type,
                                  int size) {
  DCHECK(type == JS_OBJECT_TYPE || type == JS_FUNCTION_TYPE);
2048

2049 2050
  Handle<Map> proxy_map(proxy->map());
  Handle<Map> map = Map::FixProxy(proxy_map, type, size);
2051 2052

  // Check that the receiver has at least the size of the fresh object.
2053
  int size_difference = proxy_map->instance_size() - map->instance_size();
2054
  DCHECK(size_difference >= 0);
2055 2056

  // Allocate the backing storage for the properties.
2057
  Handle<FixedArray> properties = empty_fixed_array();
2058 2059 2060 2061

  Heap* heap = isolate()->heap();
  MaybeHandle<SharedFunctionInfo> shared;
  if (type == JS_FUNCTION_TYPE) {
2062
    OneByteStringKey key(STATIC_CHAR_VECTOR("<freezing call trap>"),
2063 2064
                         heap->HashSeed());
    Handle<String> name = InternalizeStringWithKey(&key);
2065
    shared = NewSharedFunctionInfo(name, MaybeHandle<Code>());
2066 2067 2068 2069 2070 2071
  }

  // In order to keep heap in consistent state there must be no allocations
  // before object re-initialization is finished and filler object is installed.
  DisallowHeapAllocation no_allocation;

2072 2073
  // Put in filler if the new object is smaller than the old.
  if (size_difference > 0) {
2074
    Address address = proxy->address();
2075
    heap->CreateFillerObjectAt(address + map->instance_size(), size_difference);
2076
    heap->AdjustLiveBytes(*proxy, -size_difference,
2077
                          Heap::CONCURRENT_TO_SWEEPER);
2078 2079
  }

2080
  // Reset the map for the object.
2081 2082
  proxy->synchronized_set_map(*map);
  Handle<JSObject> jsobj = Handle<JSObject>::cast(proxy);
2083 2084 2085 2086

  // Reinitialize the object from the constructor map.
  heap->InitializeJSObjectFromMap(*jsobj, *properties, *map);

2087 2088 2089 2090 2091
  // The current native context is used to set up certain bits.
  // TODO(adamk): Using the current context seems wrong, it should be whatever
  // context the JSProxy originated in. But that context isn't stored anywhere.
  Handle<Context> context(isolate()->native_context());

2092 2093 2094
  // Functions require some minimal initialization.
  if (type == JS_FUNCTION_TYPE) {
    map->set_function_with_prototype(true);
2095
    Handle<JSFunction> js_function = Handle<JSFunction>::cast(proxy);
2096
    InitializeFunction(js_function, shared.ToHandleChecked(), context);
2097 2098
  } else {
    // Provide JSObjects with a constructor.
2099
    map->SetConstructor(context->object_function());
2100 2101 2102 2103
  }
}


2104 2105 2106 2107 2108 2109
Handle<JSGlobalProxy> Factory::NewUninitializedJSGlobalProxy() {
  // Create an empty shell of a JSGlobalProxy that needs to be reinitialized
  // via ReinitializeJSGlobalProxy later.
  Handle<Map> map = NewMap(JS_GLOBAL_PROXY_TYPE, JSGlobalProxy::kSize);
  // Maintain invariant expected from any JSGlobalProxy.
  map->set_is_access_check_needed(true);
2110 2111 2112
  CALL_HEAP_FUNCTION(
      isolate(), isolate()->heap()->AllocateJSObjectFromMap(*map, NOT_TENURED),
      JSGlobalProxy);
2113 2114 2115
}


2116 2117
void Factory::ReinitializeJSGlobalProxy(Handle<JSGlobalProxy> object,
                                        Handle<JSFunction> constructor) {
2118
  DCHECK(constructor->has_initial_map());
2119 2120
  Handle<Map> map(constructor->initial_map(), isolate());

2121 2122 2123
  // The proxy's hash should be retained across reinitialization.
  Handle<Object> hash(object->hash(), isolate());

2124 2125
  // Check that the already allocated object has the same size and type as
  // objects allocated using the constructor.
2126 2127
  DCHECK(map->instance_size() == object->map()->instance_size());
  DCHECK(map->instance_type() == object->map()->instance_type());
2128 2129

  // Allocate the backing storage for the properties.
2130
  Handle<FixedArray> properties = empty_fixed_array();
2131 2132 2133 2134 2135 2136

  // In order to keep heap in consistent state there must be no allocations
  // before object re-initialization is finished.
  DisallowHeapAllocation no_allocation;

  // Reset the map for the object.
2137
  object->synchronized_set_map(*map);
2138 2139 2140 2141

  Heap* heap = isolate()->heap();
  // Reinitialize the object from the constructor map.
  heap->InitializeJSObjectFromMap(*object, *properties, *map);
2142 2143 2144

  // Restore the saved hash.
  object->set_hash(*hash);
2145 2146 2147
}


2148 2149
void Factory::BecomeJSObject(Handle<JSProxy> proxy) {
  ReinitializeJSProxy(proxy, JS_OBJECT_TYPE, JSObject::kHeaderSize);
2150 2151 2152
}


2153 2154
void Factory::BecomeJSFunction(Handle<JSProxy> proxy) {
  ReinitializeJSProxy(proxy, JS_FUNCTION_TYPE, JSFunction::kSize);
2155 2156 2157
}


2158 2159 2160 2161 2162 2163 2164 2165
template Handle<TypeFeedbackVector> Factory::NewTypeFeedbackVector(
    const ZoneFeedbackVectorSpec* spec);
template Handle<TypeFeedbackVector> Factory::NewTypeFeedbackVector(
    const FeedbackVectorSpec* spec);

template <typename Spec>
Handle<TypeFeedbackVector> Factory::NewTypeFeedbackVector(const Spec* spec) {
  return TypeFeedbackVector::Allocate<Spec>(isolate(), spec);
2166 2167 2168
}


2169
Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
2170 2171
    Handle<String> name, int number_of_literals, FunctionKind kind,
    Handle<Code> code, Handle<ScopeInfo> scope_info,
2172
    Handle<TypeFeedbackVector> feedback_vector) {
2173
  DCHECK(IsValidFunctionKind(kind));
2174
  Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(name, code);
2175
  shared->set_scope_info(*scope_info);
2176
  shared->set_feedback_vector(*feedback_vector);
2177
  shared->set_kind(kind);
2178
  shared->set_num_literals(number_of_literals);
2179
  if (IsGeneratorFunction(kind)) {
2180
    shared->set_instance_class_name(isolate()->heap()->Generator_string());
2181
    shared->DisableOptimization(kGenerator);
2182
  }
2183 2184 2185 2186
  return shared;
}


2187
Handle<JSMessageObject> Factory::NewJSMessageObject(
2188 2189
    MessageTemplate::Template message, Handle<Object> argument,
    int start_position, int end_position, Handle<Object> script,
2190
    Handle<Object> stack_frames) {
2191
  Handle<Map> map = message_object_map();
2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202
  Handle<JSMessageObject> message_obj = New<JSMessageObject>(map, NEW_SPACE);
  message_obj->set_properties(*empty_fixed_array(), SKIP_WRITE_BARRIER);
  message_obj->initialize_elements();
  message_obj->set_elements(*empty_fixed_array(), SKIP_WRITE_BARRIER);
  message_obj->set_type(message);
  message_obj->set_argument(*argument);
  message_obj->set_start_position(start_position);
  message_obj->set_end_position(end_position);
  message_obj->set_script(*script);
  message_obj->set_stack_frames(*stack_frames);
  return message_obj;
2203 2204
}

2205

2206 2207 2208
Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
    Handle<String> name,
    MaybeHandle<Code> maybe_code) {
2209
  Handle<Map> map = shared_function_info_map();
2210
  Handle<SharedFunctionInfo> share = New<SharedFunctionInfo>(map, OLD_SPACE);
2211 2212 2213

  // Set pointer fields.
  share->set_name(*name);
2214 2215 2216 2217 2218
  Handle<Code> code;
  if (!maybe_code.ToHandle(&code)) {
    code = handle(isolate()->builtins()->builtin(Builtins::kIllegal));
  }
  share->set_code(*code);
2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
  share->set_optimized_code_map(Smi::FromInt(0));
  share->set_scope_info(ScopeInfo::Empty(isolate()));
  Code* construct_stub =
      isolate()->builtins()->builtin(Builtins::kJSConstructStubGeneric);
  share->set_construct_stub(construct_stub);
  share->set_instance_class_name(*Object_string());
  share->set_function_data(*undefined_value(), SKIP_WRITE_BARRIER);
  share->set_script(*undefined_value(), SKIP_WRITE_BARRIER);
  share->set_debug_info(*undefined_value(), SKIP_WRITE_BARRIER);
  share->set_inferred_name(*empty_string(), SKIP_WRITE_BARRIER);
2229
  FeedbackVectorSpec empty_spec(0);
2230
  Handle<TypeFeedbackVector> feedback_vector =
2231
      NewTypeFeedbackVector(&empty_spec);
2232
  share->set_feedback_vector(*feedback_vector, SKIP_WRITE_BARRIER);
2233 2234 2235
#if TRACE_MAPS
  share->set_unique_id(isolate()->GetNextUniqueSharedFunctionInfoId());
#endif
2236
  share->set_profiler_ticks(0);
2237 2238 2239 2240 2241
  share->set_ast_node_count(0);
  share->set_counters(0);

  // Set integer fields (smi or int, depending on the architecture).
  share->set_length(0);
2242
  share->set_internal_formal_parameter_count(0);
2243 2244 2245 2246 2247 2248 2249 2250 2251 2252
  share->set_expected_nof_properties(0);
  share->set_num_literals(0);
  share->set_start_position_and_type(0);
  share->set_end_position(0);
  share->set_function_token_position(0);
  // All compiler hints default to false or 0.
  share->set_compiler_hints(0);
  share->set_opt_count_and_bailout_reason(0);

  return share;
2253 2254 2255
}


2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297
static inline int NumberCacheHash(Handle<FixedArray> cache,
                                  Handle<Object> number) {
  int mask = (cache->length() >> 1) - 1;
  if (number->IsSmi()) {
    return Handle<Smi>::cast(number)->value() & mask;
  } else {
    DoubleRepresentation rep(number->Number());
    return
        (static_cast<int>(rep.bits) ^ static_cast<int>(rep.bits >> 32)) & mask;
  }
}


Handle<Object> Factory::GetNumberStringCache(Handle<Object> number) {
  DisallowHeapAllocation no_gc;
  int hash = NumberCacheHash(number_string_cache(), number);
  Object* key = number_string_cache()->get(hash * 2);
  if (key == *number || (key->IsHeapNumber() && number->IsHeapNumber() &&
                         key->Number() == number->Number())) {
    return Handle<String>(
        String::cast(number_string_cache()->get(hash * 2 + 1)), isolate());
  }
  return undefined_value();
}


void Factory::SetNumberStringCache(Handle<Object> number,
                                   Handle<String> string) {
  int hash = NumberCacheHash(number_string_cache(), number);
  if (number_string_cache()->get(hash * 2) != *undefined_value()) {
    int full_size = isolate()->heap()->FullSizeNumberStringCacheLength();
    if (number_string_cache()->length() != full_size) {
      Handle<FixedArray> new_cache = NewFixedArray(full_size, TENURED);
      isolate()->heap()->set_number_string_cache(*new_cache);
      return;
    }
  }
  number_string_cache()->set(hash * 2, *number);
  number_string_cache()->set(hash * 2 + 1, *string);
}


2298 2299
Handle<String> Factory::NumberToString(Handle<Object> number,
                                       bool check_number_string_cache) {
2300 2301 2302 2303 2304
  isolate()->counters()->number_to_string_runtime()->Increment();
  if (check_number_string_cache) {
    Handle<Object> cached = GetNumberStringCache(number);
    if (!cached->IsUndefined()) return Handle<String>::cast(cached);
  }
2305

2306
  char arr[100];
2307
  Vector<char> buffer(arr, arraysize(arr));
2308 2309 2310 2311 2312 2313 2314 2315
  const char* str;
  if (number->IsSmi()) {
    int num = Handle<Smi>::cast(number)->value();
    str = IntToCString(num, buffer);
  } else {
    double num = Handle<HeapNumber>::cast(number)->value();
    str = DoubleToCString(num, buffer);
  }
2316

2317 2318
  // We tenure the allocated string since it is referenced from the
  // number-string cache which lives in the old space.
2319
  Handle<String> js_string = NewStringFromAsciiChecked(str, TENURED);
2320 2321
  SetNumberStringCache(number, js_string);
  return js_string;
2322 2323 2324
}


2325 2326 2327 2328 2329
Handle<DebugInfo> Factory::NewDebugInfo(Handle<SharedFunctionInfo> shared) {
  // Allocate initial fixed array for active break points before allocating the
  // debug info object to avoid allocation while setting up the debug info
  // object.
  Handle<FixedArray> break_points(
2330
      NewFixedArray(DebugInfo::kEstimatedNofBreakPointsInFunction));
2331 2332 2333 2334 2335

  // Create and set up the debug info object. Debug info contains function, a
  // copy of the original code, the executing code and initial fixed array for
  // active break points.
  Handle<DebugInfo> debug_info =
2336
      Handle<DebugInfo>::cast(NewStruct(DEBUG_INFO_TYPE));
2337
  debug_info->set_shared(*shared);
2338
  debug_info->set_code(shared->code());
2339 2340 2341 2342 2343 2344 2345 2346 2347
  debug_info->set_break_points(*break_points);

  // Link debug info to function.
  shared->set_debug_info(*debug_info);

  return debug_info;
}


2348
Handle<JSObject> Factory::NewArgumentsObject(Handle<JSFunction> callee,
2349
                                             int length) {
2350 2351
  bool strict_mode_callee = is_strict(callee->shared()->language_mode()) ||
                            !callee->is_simple_parameter_list();
2352 2353 2354 2355 2356
  Handle<Map> map = strict_mode_callee ? isolate()->strict_arguments_map()
                                       : isolate()->sloppy_arguments_map();

  AllocationSiteUsageContext context(isolate(), Handle<AllocationSite>(),
                                     false);
2357
  DCHECK(!isolate()->has_pending_exception());
2358 2359
  Handle<JSObject> result = NewJSObjectFromMap(map);
  Handle<Smi> value(Smi::FromInt(length), isolate());
2360
  Object::SetProperty(result, length_string(), value, STRICT).Assert();
2361
  if (!strict_mode_callee) {
2362
    Object::SetProperty(result, callee_string(), callee, STRICT).Assert();
2363 2364
  }
  return result;
2365 2366 2367
}


yurys's avatar
yurys committed
2368 2369 2370 2371 2372 2373 2374 2375 2376
Handle<JSWeakMap> Factory::NewJSWeakMap() {
  // TODO(adamk): Currently the map is only created three times per
  // isolate. If it's created more often, the map should be moved into the
  // strong root list.
  Handle<Map> map = NewMap(JS_WEAK_MAP_TYPE, JSWeakMap::kSize);
  return Handle<JSWeakMap>::cast(NewJSObjectFromMap(map));
}


2377
Handle<Map> Factory::ObjectLiteralMapFromCache(Handle<Context> context,
2378
                                               int number_of_properties,
2379
                                               bool is_strong,
2380 2381 2382
                                               bool* is_result_from_cache) {
  const int kMapCacheSize = 128;

2383
  // We do not cache maps for too many properties or when running builtin code.
2384
  if (number_of_properties > kMapCacheSize ||
2385
      isolate()->bootstrapper()->IsActive()) {
2386
    *is_result_from_cache = false;
2387
    Handle<Map> map = Map::Create(isolate(), number_of_properties);
2388
    if (is_strong) map->set_is_strong();
2389
    return map;
2390 2391 2392 2393
  }
  *is_result_from_cache = true;
  if (number_of_properties == 0) {
    // Reuse the initial map of the Object function if the literal has no
2394 2395 2396 2397
    // predeclared properties, or the strong map if strong.
    return handle(is_strong
                      ? context->js_object_strong_map()
                      : context->object_function()->initial_map(), isolate());
2398
  }
2399

2400
  int cache_index = number_of_properties - 1;
2401 2402 2403 2404 2405 2406 2407 2408 2409
  Handle<Object> maybe_cache(is_strong ? context->strong_map_cache()
                                       : context->map_cache(), isolate());
  if (maybe_cache->IsUndefined()) {
    // Allocate the new map cache for the native context.
    maybe_cache = NewFixedArray(kMapCacheSize, TENURED);
    if (is_strong) {
      context->set_strong_map_cache(*maybe_cache);
    } else {
      context->set_map_cache(*maybe_cache);
2410 2411 2412
    }
  } else {
    // Check to see whether there is a matching element in the cache.
2413
    Handle<FixedArray> cache = Handle<FixedArray>::cast(maybe_cache);
2414 2415 2416 2417 2418 2419 2420 2421
    Object* result = cache->get(cache_index);
    if (result->IsWeakCell()) {
      WeakCell* cell = WeakCell::cast(result);
      if (!cell->cleared()) {
        return handle(Map::cast(cell->value()), isolate());
      }
    }
  }
2422 2423 2424 2425
  // Create a new map and add it to the cache.
  Handle<FixedArray> cache = Handle<FixedArray>::cast(maybe_cache);
  Handle<Map> map = Map::Create(isolate(), number_of_properties);
  if (is_strong) map->set_is_strong();
2426 2427
  Handle<WeakCell> cell = NewWeakCell(map);
  cache->set(cache_index, *cell);
2428
  return map;
2429 2430 2431
}


2432 2433 2434 2435 2436 2437 2438
void Factory::SetRegExpAtomData(Handle<JSRegExp> regexp,
                                JSRegExp::Type type,
                                Handle<String> source,
                                JSRegExp::Flags flags,
                                Handle<Object> data) {
  Handle<FixedArray> store = NewFixedArray(JSRegExp::kAtomDataSize);

2439 2440 2441 2442 2443 2444 2445
  store->set(JSRegExp::kTagIndex, Smi::FromInt(type));
  store->set(JSRegExp::kSourceIndex, *source);
  store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value()));
  store->set(JSRegExp::kAtomPatternIndex, *data);
  regexp->set_data(*store);
}

2446

2447 2448 2449 2450 2451 2452
void Factory::SetRegExpIrregexpData(Handle<JSRegExp> regexp,
                                    JSRegExp::Type type,
                                    Handle<String> source,
                                    JSRegExp::Flags flags,
                                    int capture_count) {
  Handle<FixedArray> store = NewFixedArray(JSRegExp::kIrregexpDataSize);
2453
  Smi* uninitialized = Smi::FromInt(JSRegExp::kUninitializedValue);
2454 2455 2456
  store->set(JSRegExp::kTagIndex, Smi::FromInt(type));
  store->set(JSRegExp::kSourceIndex, *source);
  store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value()));
2457
  store->set(JSRegExp::kIrregexpLatin1CodeIndex, uninitialized);
2458
  store->set(JSRegExp::kIrregexpUC16CodeIndex, uninitialized);
2459
  store->set(JSRegExp::kIrregexpLatin1CodeSavedIndex, uninitialized);
2460
  store->set(JSRegExp::kIrregexpUC16CodeSavedIndex, uninitialized);
2461 2462 2463 2464 2465 2466 2467
  store->set(JSRegExp::kIrregexpMaxRegisterCountIndex, Smi::FromInt(0));
  store->set(JSRegExp::kIrregexpCaptureCountIndex,
             Smi::FromInt(capture_count));
  regexp->set_data(*store);
}


2468 2469 2470 2471
Handle<Object> Factory::GlobalConstantFor(Handle<Name> name) {
  if (Name::Equals(name, undefined_string())) return undefined_value();
  if (Name::Equals(name, nan_string())) return nan_value();
  if (Name::Equals(name, infinity_string())) return infinity_value();
2472 2473 2474 2475
  return Handle<Object>::null();
}


2476
Handle<Object> Factory::ToBoolean(bool value) {
2477
  return value ? true_value() : false_value();
2478 2479
}

2480

2481 2482
}  // namespace internal
}  // namespace v8