Revision f230a1cf deps/v8/src/factory.h

View differences:

deps/v8/src/factory.h
59 59
      int size,
60 60
      PretenureFlag pretenure = NOT_TENURED);
61 61

  
62
  Handle<ConstantPoolArray> NewConstantPoolArray(
63
      int number_of_int64_entries,
64
      int number_of_ptr_entries,
65
      int number_of_int32_entries);
66

  
62 67
  Handle<SeededNumberDictionary> NewSeededNumberDictionary(
63 68
      int at_least_space_for);
64 69

  
......
71 76

  
72 77
  Handle<ObjectHashTable> NewObjectHashTable(int at_least_space_for);
73 78

  
79
  Handle<WeakHashTable> NewWeakHashTable(int at_least_space_for);
80

  
74 81
  Handle<DescriptorArray> NewDescriptorArray(int number_of_descriptors,
75 82
                                             int slack = 0);
76 83
  Handle<DeoptimizationInputData> NewDeoptimizationInputData(
......
241 248

  
242 249
  Handle<Cell> NewCell(Handle<Object> value);
243 250

  
251
  Handle<PropertyCell> NewPropertyCellWithHole();
252

  
244 253
  Handle<PropertyCell> NewPropertyCell(Handle<Object> value);
245 254

  
246 255
  Handle<AllocationSite> NewAllocationSite();
......
265 274
  Handle<FixedArray> CopyFixedArray(Handle<FixedArray> array);
266 275

  
267 276
  Handle<FixedArray> CopySizeFixedArray(Handle<FixedArray> array,
268
                                        int new_length);
277
                                        int new_length,
278
                                        PretenureFlag pretenure = NOT_TENURED);
269 279

  
270 280
  Handle<FixedDoubleArray> CopyFixedDoubleArray(
271 281
      Handle<FixedDoubleArray> array);
272 282

  
283
  Handle<ConstantPoolArray> CopyConstantPoolArray(
284
      Handle<ConstantPoolArray> array);
285

  
273 286
  // Numbers (e.g. literals) are pretenured by the parser.
274 287
  Handle<Object> NewNumber(double value,
275 288
                           PretenureFlag pretenure = NOT_TENURED);
......
295 308
  Handle<JSObject> NewJSObject(Handle<JSFunction> constructor,
296 309
                               PretenureFlag pretenure = NOT_TENURED);
297 310

  
298
  // Global objects are pretenured.
311
  // Global objects are pretenured and initialized based on a constructor.
299 312
  Handle<GlobalObject> NewGlobalObject(Handle<JSFunction> constructor);
300 313

  
301 314
  // JS objects are pretenured when allocated by the bootstrapper and
......
328 341

  
329 342
  void SetContent(Handle<JSArray> array, Handle<FixedArrayBase> elements);
330 343

  
331
  void EnsureCanContainElements(Handle<JSArray> array,
332
                                Handle<FixedArrayBase> elements,
333
                                uint32_t length,
334
                                EnsureElementsMode mode);
335

  
336 344
  Handle<JSArrayBuffer> NewJSArrayBuffer();
337 345

  
338 346
  Handle<JSTypedArray> NewJSTypedArray(ExternalArrayType type);
......
372 380
                       Code::Flags flags,
373 381
                       Handle<Object> self_reference,
374 382
                       bool immovable = false,
375
                       bool crankshafted = false);
383
                       bool crankshafted = false,
384
                       int prologue_offset = Code::kPrologueOffsetNotSet);
376 385

  
377 386
  Handle<Code> CopyCode(Handle<Code> code);
378 387

  
......
462 471
        &isolate()->heap()->roots_[Heap::k##camel_name##RootIndex]));          \
463 472
  }
464 473
  ROOT_LIST(ROOT_ACCESSOR)
465
#undef ROOT_ACCESSOR_ACCESSOR
474
#undef ROOT_ACCESSOR
475

  
476
#define STRUCT_MAP_ACCESSOR(NAME, Name, name)                                  \
477
  inline Handle<Map> name##_map() {                                            \
478
    return Handle<Map>(BitCast<Map**>(                                         \
479
        &isolate()->heap()->roots_[Heap::k##Name##MapRootIndex]));             \
480
    }
481
  STRUCT_LIST(STRUCT_MAP_ACCESSOR)
482
#undef STRUCT_MAP_ACCESSOR
466 483

  
467 484
#define STRING_ACCESSOR(name, str)                                             \
468 485
  inline Handle<String> name() {                                               \

Also available in: Unified diff