CSE2410 Fall 2014 Bounce

Handle<ConstantPoolArray> Factory::NewConstantPoolArray(

    int number_of_int64_entries,

    int number_of_ptr_entries,

    int number_of_int32_entries) {

  ASSERT(number_of_int64_entries > 0 || number_of_ptr_entries > 0 ||

         number_of_int32_entries > 0);

  CALL_HEAP_FUNCTION(

      isolate(),

      isolate()->heap()->AllocateConstantPoolArray(number_of_int64_entries,

                                                   number_of_ptr_entries,

                                                   number_of_int32_entries),

      ConstantPoolArray);

}

Handle<WeakHashTable> Factory::NewWeakHashTable(int at_least_space_for) {

  ASSERT(0 <= at_least_space_for);

  CALL_HEAP_FUNCTION(

      isolate(),

      WeakHashTable::Allocate(isolate()->heap(),

                              at_least_space_for,

                              WeakHashTable::USE_DEFAULT_MINIMUM_CAPACITY,

                              TENURED),

      WeakHashTable);

}

Handle<PropertyCell> Factory::NewPropertyCellWithHole() {

      isolate()->heap()->AllocatePropertyCell(),

Handle<PropertyCell> Factory::NewPropertyCell(Handle<Object> value) {

  AllowDeferredHandleDereference convert_to_cell;

  Handle<PropertyCell> cell = NewPropertyCellWithHole();

  PropertyCell::SetValueInferType(cell, value);

  return cell;

}

                                               int new_length,

                                               PretenureFlag pretenure) {

  CALL_HEAP_FUNCTION(isolate(),

                     array->CopySize(new_length, pretenure),

                     FixedArray);

Handle<ConstantPoolArray> Factory::CopyConstantPoolArray(

    Handle<ConstantPoolArray> array) {

  CALL_HEAP_FUNCTION(isolate(), array->Copy(), ConstantPoolArray);

}

                              bool crankshafted,

                              int prologue_offset) {

                         desc, flags, self_ref, immovable, crankshafted,

                         prologue_offset),

// TODO(mstarzinger): Temporary wrapper until handlified.

static Handle<NameDictionary> NameDictionaryAdd(Handle<NameDictionary> dict,

                                                Handle<Name> name,

                                                Handle<Object> value,

                                                PropertyDetails details) {

  CALL_HEAP_FUNCTION(dict->GetIsolate(),

                     dict->Add(*name, *value, details),

                     NameDictionary);

}

static Handle<GlobalObject> NewGlobalObjectFromMap(Isolate* isolate,

                                                   Handle<Map> map) {

  CALL_HEAP_FUNCTION(isolate,

                     isolate->heap()->Allocate(*map, OLD_POINTER_SPACE),

Handle<GlobalObject> Factory::NewGlobalObject(Handle<JSFunction> constructor) {

  ASSERT(constructor->has_initial_map());

  Handle<Map> map(constructor->initial_map());

  ASSERT(map->is_dictionary_map());

  // 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.

  ASSERT(map->NextFreePropertyIndex() == 0);

  // 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.

  ASSERT(map->unused_property_fields() == 0);

  ASSERT(map->inobject_properties() == 0);

  // 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;

  Handle<NameDictionary> dictionary = NewNameDictionary(at_least_space_for);

  // 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);

    ASSERT(details.type() == CALLBACKS);  // Only accessors are expected.

    PropertyDetails d = PropertyDetails(details.attributes(), CALLBACKS, i + 1);

    Handle<Name> name(descs->GetKey(i));

    Handle<Object> value(descs->GetCallbacksObject(i), isolate());

    Handle<PropertyCell> cell = NewPropertyCell(value);

    NameDictionaryAdd(dictionary, name, cell, d);

  }

  // Allocate the global object and initialize it with the backing store.

  Handle<GlobalObject> global = NewGlobalObjectFromMap(isolate(), map);

  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.

  ASSERT(global->IsGlobalObject() && !global->HasFastProperties());

  return global;

}