1// Copyright 2014 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "src/bootstrapper.h"
6
7#include "src/accessors.h"
8#include "src/api-natives.h"
9#include "src/base/ieee754.h"
10#include "src/code-stubs.h"
11#include "src/compiler.h"
12#include "src/debug/debug.h"
13#include "src/extensions/externalize-string-extension.h"
14#include "src/extensions/free-buffer-extension.h"
15#include "src/extensions/gc-extension.h"
16#include "src/extensions/ignition-statistics-extension.h"
17#include "src/extensions/statistics-extension.h"
18#include "src/extensions/trigger-failure-extension.h"
19#include "src/ffi/ffi-compiler.h"
20#include "src/heap/heap.h"
21#include "src/isolate-inl.h"
22#include "src/snapshot/natives.h"
23#include "src/snapshot/snapshot.h"
24#include "src/wasm/wasm-js.h"
25
26#if V8_I18N_SUPPORT
27#include "src/i18n.h"
28#endif  // V8_I18N_SUPPORT
29
30namespace v8 {
31namespace internal {
32
33Bootstrapper::Bootstrapper(Isolate* isolate)
34    : isolate_(isolate),
35      nesting_(0),
36      extensions_cache_(Script::TYPE_EXTENSION) {}
37
38template <class Source>
39Handle<String> Bootstrapper::SourceLookup(int index) {
40  DCHECK(0 <= index && index < Source::GetBuiltinsCount());
41  Heap* heap = isolate_->heap();
42  if (Source::GetSourceCache(heap)->get(index)->IsUndefined(isolate_)) {
43    // We can use external strings for the natives.
44    Vector<const char> source = Source::GetScriptSource(index);
45    NativesExternalStringResource* resource =
46        new NativesExternalStringResource(source.start(), source.length());
47    Handle<ExternalOneByteString> source_code =
48        isolate_->factory()->NewNativeSourceString(resource);
49    // Mark this external string with a special map.
50    DCHECK(source_code->is_short());
51    Source::GetSourceCache(heap)->set(index, *source_code);
52  }
53  Handle<Object> cached_source(Source::GetSourceCache(heap)->get(index),
54                               isolate_);
55  return Handle<String>::cast(cached_source);
56}
57
58
59template Handle<String> Bootstrapper::SourceLookup<Natives>(int index);
60template Handle<String> Bootstrapper::SourceLookup<ExperimentalNatives>(
61    int index);
62template Handle<String> Bootstrapper::SourceLookup<ExperimentalExtraNatives>(
63    int index);
64template Handle<String> Bootstrapper::SourceLookup<ExtraNatives>(int index);
65
66
67void Bootstrapper::Initialize(bool create_heap_objects) {
68  extensions_cache_.Initialize(isolate_, create_heap_objects);
69}
70
71
72static const char* GCFunctionName() {
73  bool flag_given = FLAG_expose_gc_as != NULL && strlen(FLAG_expose_gc_as) != 0;
74  return flag_given ? FLAG_expose_gc_as : "gc";
75}
76
77
78v8::Extension* Bootstrapper::free_buffer_extension_ = NULL;
79v8::Extension* Bootstrapper::gc_extension_ = NULL;
80v8::Extension* Bootstrapper::externalize_string_extension_ = NULL;
81v8::Extension* Bootstrapper::statistics_extension_ = NULL;
82v8::Extension* Bootstrapper::trigger_failure_extension_ = NULL;
83v8::Extension* Bootstrapper::ignition_statistics_extension_ = NULL;
84
85void Bootstrapper::InitializeOncePerProcess() {
86  free_buffer_extension_ = new FreeBufferExtension;
87  v8::RegisterExtension(free_buffer_extension_);
88  gc_extension_ = new GCExtension(GCFunctionName());
89  v8::RegisterExtension(gc_extension_);
90  externalize_string_extension_ = new ExternalizeStringExtension;
91  v8::RegisterExtension(externalize_string_extension_);
92  statistics_extension_ = new StatisticsExtension;
93  v8::RegisterExtension(statistics_extension_);
94  trigger_failure_extension_ = new TriggerFailureExtension;
95  v8::RegisterExtension(trigger_failure_extension_);
96  ignition_statistics_extension_ = new IgnitionStatisticsExtension;
97  v8::RegisterExtension(ignition_statistics_extension_);
98}
99
100
101void Bootstrapper::TearDownExtensions() {
102  delete free_buffer_extension_;
103  free_buffer_extension_ = NULL;
104  delete gc_extension_;
105  gc_extension_ = NULL;
106  delete externalize_string_extension_;
107  externalize_string_extension_ = NULL;
108  delete statistics_extension_;
109  statistics_extension_ = NULL;
110  delete trigger_failure_extension_;
111  trigger_failure_extension_ = NULL;
112  delete ignition_statistics_extension_;
113  ignition_statistics_extension_ = NULL;
114}
115
116
117void DeleteNativeSources(Object* maybe_array) {
118  if (maybe_array->IsFixedArray()) {
119    FixedArray* array = FixedArray::cast(maybe_array);
120    Isolate* isolate = array->GetIsolate();
121    for (int i = 0; i < array->length(); i++) {
122      Object* natives_source = array->get(i);
123      if (!natives_source->IsUndefined(isolate)) {
124        const NativesExternalStringResource* resource =
125            reinterpret_cast<const NativesExternalStringResource*>(
126                ExternalOneByteString::cast(natives_source)->resource());
127        delete resource;
128      }
129    }
130  }
131}
132
133
134void Bootstrapper::TearDown() {
135  DeleteNativeSources(Natives::GetSourceCache(isolate_->heap()));
136  DeleteNativeSources(ExperimentalNatives::GetSourceCache(isolate_->heap()));
137  DeleteNativeSources(ExtraNatives::GetSourceCache(isolate_->heap()));
138  DeleteNativeSources(
139      ExperimentalExtraNatives::GetSourceCache(isolate_->heap()));
140
141  extensions_cache_.Initialize(isolate_, false);  // Yes, symmetrical
142}
143
144
145class Genesis BASE_EMBEDDED {
146 public:
147  Genesis(Isolate* isolate, MaybeHandle<JSGlobalProxy> maybe_global_proxy,
148          v8::Local<v8::ObjectTemplate> global_proxy_template,
149          size_t context_snapshot_index,
150          v8::DeserializeInternalFieldsCallback internal_fields_deserializer,
151          GlobalContextType context_type);
152  Genesis(Isolate* isolate, MaybeHandle<JSGlobalProxy> maybe_global_proxy,
153          v8::Local<v8::ObjectTemplate> global_proxy_template);
154  ~Genesis() { }
155
156  Isolate* isolate() const { return isolate_; }
157  Factory* factory() const { return isolate_->factory(); }
158  Heap* heap() const { return isolate_->heap(); }
159
160  Handle<Context> result() { return result_; }
161
162  Handle<JSGlobalProxy> global_proxy() { return global_proxy_; }
163
164 private:
165  Handle<Context> native_context() { return native_context_; }
166
167  // Creates some basic objects. Used for creating a context from scratch.
168  void CreateRoots();
169  // Creates the empty function.  Used for creating a context from scratch.
170  Handle<JSFunction> CreateEmptyFunction(Isolate* isolate);
171  // Creates the ThrowTypeError function. ECMA 5th Ed. 13.2.3
172  Handle<JSFunction> GetRestrictedFunctionPropertiesThrower();
173  Handle<JSFunction> GetStrictArgumentsPoisonFunction();
174  Handle<JSFunction> GetThrowTypeErrorIntrinsic(Builtins::Name builtin_name);
175
176  void CreateStrictModeFunctionMaps(Handle<JSFunction> empty);
177  void CreateIteratorMaps(Handle<JSFunction> empty);
178  void CreateAsyncIteratorMaps();
179  void CreateAsyncFunctionMaps(Handle<JSFunction> empty);
180  void CreateJSProxyMaps();
181
182  // Make the "arguments" and "caller" properties throw a TypeError on access.
183  void AddRestrictedFunctionProperties(Handle<JSFunction> empty);
184
185  // Creates the global objects using the global proxy and the template passed
186  // in through the API.  We call this regardless of whether we are building a
187  // context from scratch or using a deserialized one from the partial snapshot
188  // but in the latter case we don't use the objects it produces directly, as
189  // we have to use the deserialized ones that are linked together with the
190  // rest of the context snapshot. At the end we link the global proxy and the
191  // context to each other.
192  Handle<JSGlobalObject> CreateNewGlobals(
193      v8::Local<v8::ObjectTemplate> global_proxy_template,
194      Handle<JSGlobalProxy> global_proxy);
195  // Similarly, we want to use the global that has been created by the templates
196  // passed through the API.  The global from the snapshot is detached from the
197  // other objects in the snapshot.
198  void HookUpGlobalObject(Handle<JSGlobalObject> global_object);
199  // Hooks the given global proxy into the context in the case we do not
200  // replace the global object from the deserialized native context.
201  void HookUpGlobalProxy(Handle<JSGlobalProxy> global_proxy);
202  // The native context has a ScriptContextTable that store declarative bindings
203  // made in script scopes.  Add a "this" binding to that table pointing to the
204  // global proxy.
205  void InstallGlobalThisBinding();
206  // New context initialization.  Used for creating a context from scratch.
207  void InitializeGlobal(Handle<JSGlobalObject> global_object,
208                        Handle<JSFunction> empty_function,
209                        GlobalContextType context_type);
210  void InitializeExperimentalGlobal();
211  // Depending on the situation, expose and/or get rid of the utils object.
212  void ConfigureUtilsObject(GlobalContextType context_type);
213
214#define DECLARE_FEATURE_INITIALIZATION(id, descr) \
215  void InitializeGlobal_##id();
216
217  HARMONY_INPROGRESS(DECLARE_FEATURE_INITIALIZATION)
218  HARMONY_STAGED(DECLARE_FEATURE_INITIALIZATION)
219  HARMONY_SHIPPING(DECLARE_FEATURE_INITIALIZATION)
220#undef DECLARE_FEATURE_INITIALIZATION
221
222  void InitializeGlobal_enable_fast_array_builtins();
223
224  Handle<JSFunction> InstallArrayBuffer(Handle<JSObject> target,
225                                        const char* name, Builtins::Name call,
226                                        BuiltinFunctionId id);
227  Handle<JSFunction> InstallInternalArray(Handle<JSObject> target,
228                                          const char* name,
229                                          ElementsKind elements_kind);
230  bool InstallNatives(GlobalContextType context_type);
231
232  void InstallTypedArray(const char* name, ElementsKind elements_kind,
233                         Handle<JSFunction>* fun);
234  bool InstallExperimentalNatives();
235  bool InstallExtraNatives();
236  bool InstallExperimentalExtraNatives();
237  bool InstallDebuggerNatives();
238  void InstallBuiltinFunctionIds();
239  void InstallExperimentalBuiltinFunctionIds();
240  void InitializeNormalizedMapCaches();
241
242  enum ExtensionTraversalState {
243    UNVISITED, VISITED, INSTALLED
244  };
245
246  class ExtensionStates {
247   public:
248    ExtensionStates();
249    ExtensionTraversalState get_state(RegisteredExtension* extension);
250    void set_state(RegisteredExtension* extension,
251                   ExtensionTraversalState state);
252   private:
253    base::HashMap map_;
254    DISALLOW_COPY_AND_ASSIGN(ExtensionStates);
255  };
256
257  // Used both for deserialized and from-scratch contexts to add the extensions
258  // provided.
259  static bool InstallExtensions(Handle<Context> native_context,
260                                v8::ExtensionConfiguration* extensions);
261  static bool InstallAutoExtensions(Isolate* isolate,
262                                    ExtensionStates* extension_states);
263  static bool InstallRequestedExtensions(Isolate* isolate,
264                                         v8::ExtensionConfiguration* extensions,
265                                         ExtensionStates* extension_states);
266  static bool InstallExtension(Isolate* isolate,
267                               const char* name,
268                               ExtensionStates* extension_states);
269  static bool InstallExtension(Isolate* isolate,
270                               v8::RegisteredExtension* current,
271                               ExtensionStates* extension_states);
272  static bool InstallSpecialObjects(Handle<Context> native_context);
273  bool ConfigureApiObject(Handle<JSObject> object,
274                          Handle<ObjectTemplateInfo> object_template);
275  bool ConfigureGlobalObjects(
276      v8::Local<v8::ObjectTemplate> global_proxy_template);
277
278  // Migrates all properties from the 'from' object to the 'to'
279  // object and overrides the prototype in 'to' with the one from
280  // 'from'.
281  void TransferObject(Handle<JSObject> from, Handle<JSObject> to);
282  void TransferNamedProperties(Handle<JSObject> from, Handle<JSObject> to);
283  void TransferIndexedProperties(Handle<JSObject> from, Handle<JSObject> to);
284
285  void MakeFunctionInstancePrototypeWritable();
286
287  void SetStrictFunctionInstanceDescriptor(Handle<Map> map,
288                                           FunctionMode function_mode);
289
290  static bool CallUtilsFunction(Isolate* isolate, const char* name);
291
292  static bool CompileExtension(Isolate* isolate, v8::Extension* extension);
293
294  Isolate* isolate_;
295  Handle<Context> result_;
296  Handle<Context> native_context_;
297  Handle<JSGlobalProxy> global_proxy_;
298
299  // Function maps. Function maps are created initially with a read only
300  // prototype for the processing of JS builtins. Later the function maps are
301  // replaced in order to make prototype writable. These are the final, writable
302  // prototype, maps.
303  Handle<Map> sloppy_function_map_writable_prototype_;
304  Handle<Map> strict_function_map_writable_prototype_;
305  Handle<Map> class_function_map_;
306  Handle<JSFunction> strict_poison_function_;
307  Handle<JSFunction> restricted_function_properties_thrower_;
308
309  BootstrapperActive active_;
310  friend class Bootstrapper;
311};
312
313
314void Bootstrapper::Iterate(ObjectVisitor* v) {
315  extensions_cache_.Iterate(v);
316  v->Synchronize(VisitorSynchronization::kExtensions);
317}
318
319Handle<Context> Bootstrapper::CreateEnvironment(
320    MaybeHandle<JSGlobalProxy> maybe_global_proxy,
321    v8::Local<v8::ObjectTemplate> global_proxy_template,
322    v8::ExtensionConfiguration* extensions, size_t context_snapshot_index,
323    v8::DeserializeInternalFieldsCallback internal_fields_deserializer,
324    GlobalContextType context_type) {
325  HandleScope scope(isolate_);
326  Genesis genesis(isolate_, maybe_global_proxy, global_proxy_template,
327                  context_snapshot_index, internal_fields_deserializer,
328                  context_type);
329  Handle<Context> env = genesis.result();
330  if (env.is_null() || !InstallExtensions(env, extensions)) {
331    return Handle<Context>();
332  }
333  return scope.CloseAndEscape(env);
334}
335
336Handle<JSGlobalProxy> Bootstrapper::NewRemoteContext(
337    MaybeHandle<JSGlobalProxy> maybe_global_proxy,
338    v8::Local<v8::ObjectTemplate> global_proxy_template) {
339  HandleScope scope(isolate_);
340  Genesis genesis(isolate_, maybe_global_proxy, global_proxy_template);
341  Handle<JSGlobalProxy> global_proxy = genesis.global_proxy();
342  if (global_proxy.is_null()) return Handle<JSGlobalProxy>();
343  return scope.CloseAndEscape(global_proxy);
344}
345
346void Bootstrapper::DetachGlobal(Handle<Context> env) {
347  Isolate* isolate = env->GetIsolate();
348  isolate->counters()->errors_thrown_per_context()->AddSample(
349      env->GetErrorsThrown());
350
351  Heap* heap = isolate->heap();
352  Handle<JSGlobalProxy> global_proxy(JSGlobalProxy::cast(env->global_proxy()));
353  global_proxy->set_native_context(heap->null_value());
354  JSObject::ForceSetPrototype(global_proxy, isolate->factory()->null_value());
355  global_proxy->map()->SetConstructor(heap->null_value());
356  if (FLAG_track_detached_contexts) {
357    env->GetIsolate()->AddDetachedContext(env);
358  }
359}
360
361namespace {
362
363void InstallFunction(Handle<JSObject> target, Handle<Name> property_name,
364                     Handle<JSFunction> function, Handle<String> function_name,
365                     PropertyAttributes attributes = DONT_ENUM) {
366  JSObject::AddProperty(target, property_name, function, attributes);
367  if (target->IsJSGlobalObject()) {
368    function->shared()->set_instance_class_name(*function_name);
369  }
370}
371
372void InstallFunction(Handle<JSObject> target, Handle<JSFunction> function,
373                     Handle<Name> name,
374                     PropertyAttributes attributes = DONT_ENUM) {
375  Handle<String> name_string = Name::ToFunctionName(name).ToHandleChecked();
376  InstallFunction(target, name, function, name_string, attributes);
377}
378
379Handle<JSFunction> CreateFunction(Isolate* isolate, Handle<String> name,
380                                  InstanceType type, int instance_size,
381                                  MaybeHandle<JSObject> maybe_prototype,
382                                  Builtins::Name call,
383                                  bool strict_function_map = false) {
384  Factory* factory = isolate->factory();
385  Handle<Code> call_code(isolate->builtins()->builtin(call));
386  Handle<JSObject> prototype;
387  Handle<JSFunction> result =
388      maybe_prototype.ToHandle(&prototype)
389          ? factory->NewFunction(name, call_code, prototype, type,
390                                 instance_size, strict_function_map)
391          : factory->NewFunctionWithoutPrototype(name, call_code,
392                                                 strict_function_map);
393  result->shared()->set_native(true);
394  return result;
395}
396
397Handle<JSFunction> InstallFunction(Handle<JSObject> target, Handle<Name> name,
398                                   InstanceType type, int instance_size,
399                                   MaybeHandle<JSObject> maybe_prototype,
400                                   Builtins::Name call,
401                                   PropertyAttributes attributes,
402                                   bool strict_function_map = false) {
403  Handle<String> name_string = Name::ToFunctionName(name).ToHandleChecked();
404  Handle<JSFunction> function =
405      CreateFunction(target->GetIsolate(), name_string, type, instance_size,
406                     maybe_prototype, call, strict_function_map);
407  InstallFunction(target, name, function, name_string, attributes);
408  return function;
409}
410
411Handle<JSFunction> InstallFunction(Handle<JSObject> target, const char* name,
412                                   InstanceType type, int instance_size,
413                                   MaybeHandle<JSObject> maybe_prototype,
414                                   Builtins::Name call,
415                                   bool strict_function_map = false) {
416  Factory* const factory = target->GetIsolate()->factory();
417  PropertyAttributes attributes = DONT_ENUM;
418  return InstallFunction(target, factory->InternalizeUtf8String(name), type,
419                         instance_size, maybe_prototype, call, attributes,
420                         strict_function_map);
421}
422
423Handle<JSFunction> SimpleCreateFunction(Isolate* isolate, Handle<String> name,
424                                        Builtins::Name call, int len,
425                                        bool adapt) {
426  Handle<JSFunction> fun =
427      CreateFunction(isolate, name, JS_OBJECT_TYPE, JSObject::kHeaderSize,
428                     MaybeHandle<JSObject>(), call);
429  if (adapt) {
430    fun->shared()->set_internal_formal_parameter_count(len);
431  } else {
432    fun->shared()->DontAdaptArguments();
433  }
434  fun->shared()->set_length(len);
435  return fun;
436}
437
438Handle<JSFunction> SimpleInstallFunction(Handle<JSObject> base,
439                                         Handle<String> name,
440                                         Builtins::Name call, int len,
441                                         bool adapt,
442                                         PropertyAttributes attrs = DONT_ENUM) {
443  Handle<JSFunction> fun =
444      SimpleCreateFunction(base->GetIsolate(), name, call, len, adapt);
445  InstallFunction(base, fun, name, attrs);
446  return fun;
447}
448
449Handle<JSFunction> SimpleInstallFunction(Handle<JSObject> base,
450                                         const char* name, Builtins::Name call,
451                                         int len, bool adapt,
452                                         PropertyAttributes attrs = DONT_ENUM) {
453  Factory* const factory = base->GetIsolate()->factory();
454  return SimpleInstallFunction(base, factory->InternalizeUtf8String(name), call,
455                               len, adapt, attrs);
456}
457
458Handle<JSFunction> SimpleInstallFunction(Handle<JSObject> base,
459                                         const char* name, Builtins::Name call,
460                                         int len, bool adapt,
461                                         BuiltinFunctionId id) {
462  Handle<JSFunction> fun = SimpleInstallFunction(base, name, call, len, adapt);
463  fun->shared()->set_builtin_function_id(id);
464  return fun;
465}
466
467void SimpleInstallGetterSetter(Handle<JSObject> base, Handle<String> name,
468                               Builtins::Name call_getter,
469                               Builtins::Name call_setter,
470                               PropertyAttributes attribs) {
471  Isolate* const isolate = base->GetIsolate();
472
473  Handle<String> getter_name =
474      Name::ToFunctionName(name, isolate->factory()->get_string())
475          .ToHandleChecked();
476  Handle<JSFunction> getter =
477      SimpleCreateFunction(isolate, getter_name, call_getter, 0, true);
478
479  Handle<String> setter_name =
480      Name::ToFunctionName(name, isolate->factory()->set_string())
481          .ToHandleChecked();
482  Handle<JSFunction> setter =
483      SimpleCreateFunction(isolate, setter_name, call_setter, 1, true);
484
485  JSObject::DefineAccessor(base, name, getter, setter, attribs).Check();
486}
487
488Handle<JSFunction> SimpleInstallGetter(Handle<JSObject> base,
489                                       Handle<String> name,
490                                       Handle<Name> property_name,
491                                       Builtins::Name call, bool adapt) {
492  Isolate* const isolate = base->GetIsolate();
493
494  Handle<String> getter_name =
495      Name::ToFunctionName(name, isolate->factory()->get_string())
496          .ToHandleChecked();
497  Handle<JSFunction> getter =
498      SimpleCreateFunction(isolate, getter_name, call, 0, adapt);
499
500  Handle<Object> setter = isolate->factory()->undefined_value();
501
502  JSObject::DefineAccessor(base, property_name, getter, setter, DONT_ENUM)
503      .Check();
504
505  return getter;
506}
507
508Handle<JSFunction> SimpleInstallGetter(Handle<JSObject> base,
509                                       Handle<String> name, Builtins::Name call,
510                                       bool adapt) {
511  return SimpleInstallGetter(base, name, name, call, adapt);
512}
513
514Handle<JSFunction> SimpleInstallGetter(Handle<JSObject> base,
515                                       Handle<String> name, Builtins::Name call,
516                                       bool adapt, BuiltinFunctionId id) {
517  Handle<JSFunction> fun = SimpleInstallGetter(base, name, call, adapt);
518  fun->shared()->set_builtin_function_id(id);
519  return fun;
520}
521
522void InstallConstant(Isolate* isolate, Handle<JSObject> holder,
523                     const char* name, Handle<Object> value) {
524  JSObject::AddProperty(
525      holder, isolate->factory()->NewStringFromAsciiChecked(name), value,
526      static_cast<PropertyAttributes>(DONT_DELETE | DONT_ENUM | READ_ONLY));
527}
528
529void InstallSpeciesGetter(Handle<JSFunction> constructor) {
530  Factory* factory = constructor->GetIsolate()->factory();
531  // TODO(adamk): We should be able to share a SharedFunctionInfo
532  // between all these JSFunctins.
533  SimpleInstallGetter(constructor, factory->symbol_species_string(),
534                      factory->species_symbol(), Builtins::kReturnReceiver,
535                      true);
536}
537
538}  // namespace
539
540Handle<JSFunction> Genesis::CreateEmptyFunction(Isolate* isolate) {
541  // Allocate the map for function instances. Maps are allocated first and their
542  // prototypes patched later, once empty function is created.
543
544  // Functions with this map will not have a 'prototype' property, and
545  // can not be used as constructors.
546  Handle<Map> function_without_prototype_map =
547      factory()->CreateSloppyFunctionMap(FUNCTION_WITHOUT_PROTOTYPE);
548  native_context()->set_sloppy_function_without_prototype_map(
549      *function_without_prototype_map);
550
551  // Allocate the function map. This map is temporary, used only for processing
552  // of builtins.
553  // Later the map is replaced with writable prototype map, allocated below.
554  Handle<Map> function_map =
555      factory()->CreateSloppyFunctionMap(FUNCTION_WITH_READONLY_PROTOTYPE);
556  native_context()->set_sloppy_function_map(*function_map);
557  native_context()->set_sloppy_function_with_readonly_prototype_map(
558      *function_map);
559
560  // The final map for functions. Writeable prototype.
561  // This map is installed in MakeFunctionInstancePrototypeWritable.
562  sloppy_function_map_writable_prototype_ =
563      factory()->CreateSloppyFunctionMap(FUNCTION_WITH_WRITEABLE_PROTOTYPE);
564  Factory* factory = isolate->factory();
565
566  Handle<String> object_name = factory->Object_string();
567
568  Handle<JSObject> object_function_prototype;
569
570  {  // --- O b j e c t ---
571    Handle<JSFunction> object_fun = factory->NewFunction(object_name);
572    int unused = JSObject::kInitialGlobalObjectUnusedPropertiesCount;
573    int instance_size = JSObject::kHeaderSize + kPointerSize * unused;
574    Handle<Map> object_function_map =
575        factory->NewMap(JS_OBJECT_TYPE, instance_size);
576    object_function_map->SetInObjectProperties(unused);
577    JSFunction::SetInitialMap(object_fun, object_function_map,
578                              isolate->factory()->null_value());
579    object_function_map->set_unused_property_fields(unused);
580
581    native_context()->set_object_function(*object_fun);
582
583    // Allocate a new prototype for the object function.
584    object_function_prototype =
585        factory->NewJSObject(isolate->object_function(), TENURED);
586    Handle<Map> map = Map::Copy(handle(object_function_prototype->map()),
587                                "EmptyObjectPrototype");
588    map->set_is_prototype_map(true);
589    // Ban re-setting Object.prototype.__proto__ to prevent Proxy security bug
590    map->set_immutable_proto(true);
591    object_function_prototype->set_map(*map);
592
593    native_context()->set_initial_object_prototype(*object_function_prototype);
594    // For bootstrapping set the array prototype to be the same as the object
595    // prototype, otherwise the missing initial_array_prototype will cause
596    // assertions during startup.
597    native_context()->set_initial_array_prototype(*object_function_prototype);
598    Accessors::FunctionSetPrototype(object_fun, object_function_prototype)
599        .Assert();
600  }
601
602  // Allocate the empty function as the prototype for function - ES6 19.2.3
603  Handle<Code> code(isolate->builtins()->EmptyFunction());
604  Handle<JSFunction> empty_function =
605      factory->NewFunctionWithoutPrototype(factory->empty_string(), code);
606
607  // Allocate the function map first and then patch the prototype later
608  Handle<Map> empty_function_map =
609      factory->CreateSloppyFunctionMap(FUNCTION_WITHOUT_PROTOTYPE);
610  DCHECK(!empty_function_map->is_dictionary_map());
611  Map::SetPrototype(empty_function_map, object_function_prototype);
612  empty_function_map->set_is_prototype_map(true);
613
614  empty_function->set_map(*empty_function_map);
615
616  // --- E m p t y ---
617  Handle<String> source = factory->NewStringFromStaticChars("() {}");
618  Handle<Script> script = factory->NewScript(source);
619  script->set_type(Script::TYPE_NATIVE);
620  Handle<FixedArray> infos = factory->NewFixedArray(2);
621  script->set_shared_function_infos(*infos);
622  empty_function->shared()->set_start_position(0);
623  empty_function->shared()->set_end_position(source->length());
624  empty_function->shared()->set_function_literal_id(1);
625  empty_function->shared()->DontAdaptArguments();
626  SharedFunctionInfo::SetScript(handle(empty_function->shared()), script);
627
628  // Set prototypes for the function maps.
629  Handle<Map> sloppy_function_map(native_context()->sloppy_function_map(),
630                                  isolate);
631  Handle<Map> sloppy_function_without_prototype_map(
632      native_context()->sloppy_function_without_prototype_map(), isolate);
633  Map::SetPrototype(sloppy_function_map, empty_function);
634  Map::SetPrototype(sloppy_function_without_prototype_map, empty_function);
635  Map::SetPrototype(sloppy_function_map_writable_prototype_, empty_function);
636
637  return empty_function;
638}
639
640
641// Creates the %ThrowTypeError% function.
642Handle<JSFunction> Genesis::GetThrowTypeErrorIntrinsic(
643    Builtins::Name builtin_name) {
644  Handle<String> name =
645      factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("ThrowTypeError"));
646  Handle<Code> code(isolate()->builtins()->builtin(builtin_name));
647  Handle<JSFunction> function =
648      factory()->NewFunctionWithoutPrototype(name, code, true);
649  function->shared()->DontAdaptArguments();
650
651  // %ThrowTypeError% must not have a name property.
652  if (JSReceiver::DeleteProperty(function, factory()->name_string())
653          .IsNothing()) {
654    DCHECK(false);
655  }
656
657  // length needs to be non configurable.
658  Handle<Object> value(Smi::FromInt(function->shared()->length()), isolate());
659  JSObject::SetOwnPropertyIgnoreAttributes(
660      function, factory()->length_string(), value,
661      static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY))
662      .Assert();
663
664  if (JSObject::PreventExtensions(function, Object::THROW_ON_ERROR)
665          .IsNothing()) {
666    DCHECK(false);
667  }
668
669  return function;
670}
671
672
673// ECMAScript 5th Edition, 13.2.3
674Handle<JSFunction> Genesis::GetRestrictedFunctionPropertiesThrower() {
675  if (restricted_function_properties_thrower_.is_null()) {
676    restricted_function_properties_thrower_ = GetThrowTypeErrorIntrinsic(
677        Builtins::kRestrictedFunctionPropertiesThrower);
678  }
679  return restricted_function_properties_thrower_;
680}
681
682
683Handle<JSFunction> Genesis::GetStrictArgumentsPoisonFunction() {
684  if (strict_poison_function_.is_null()) {
685    strict_poison_function_ = GetThrowTypeErrorIntrinsic(
686        Builtins::kRestrictedStrictArgumentsPropertiesThrower);
687  }
688  return strict_poison_function_;
689}
690
691
692void Genesis::CreateStrictModeFunctionMaps(Handle<JSFunction> empty) {
693  // Allocate map for the prototype-less strict mode instances.
694  Handle<Map> strict_function_without_prototype_map =
695      factory()->CreateStrictFunctionMap(FUNCTION_WITHOUT_PROTOTYPE, empty);
696  native_context()->set_strict_function_without_prototype_map(
697      *strict_function_without_prototype_map);
698
699  // Allocate map for the strict mode functions. This map is temporary, used
700  // only for processing of builtins.
701  // Later the map is replaced with writable prototype map, allocated below.
702  Handle<Map> strict_function_map = factory()->CreateStrictFunctionMap(
703      FUNCTION_WITH_READONLY_PROTOTYPE, empty);
704  native_context()->set_strict_function_map(*strict_function_map);
705
706  // The final map for the strict mode functions. Writeable prototype.
707  // This map is installed in MakeFunctionInstancePrototypeWritable.
708  strict_function_map_writable_prototype_ = factory()->CreateStrictFunctionMap(
709      FUNCTION_WITH_WRITEABLE_PROTOTYPE, empty);
710
711  // Allocate map for classes
712  class_function_map_ = factory()->CreateClassFunctionMap(empty);
713  native_context()->set_class_function_map(*class_function_map_);
714
715  // Now that the strict mode function map is available, set up the
716  // restricted "arguments" and "caller" getters.
717  AddRestrictedFunctionProperties(empty);
718}
719
720void Genesis::CreateIteratorMaps(Handle<JSFunction> empty) {
721  // Create iterator-related meta-objects.
722  Handle<JSObject> iterator_prototype =
723      factory()->NewJSObject(isolate()->object_function(), TENURED);
724
725  Handle<JSFunction> iterator_prototype_iterator = SimpleCreateFunction(
726      isolate(), factory()->NewStringFromAsciiChecked("[Symbol.iterator]"),
727      Builtins::kReturnReceiver, 0, true);
728
729  JSObject::AddProperty(iterator_prototype, factory()->iterator_symbol(),
730                        iterator_prototype_iterator, DONT_ENUM);
731  native_context()->set_initial_iterator_prototype(*iterator_prototype);
732
733  Handle<JSObject> generator_object_prototype =
734      factory()->NewJSObject(isolate()->object_function(), TENURED);
735  native_context()->set_initial_generator_prototype(
736      *generator_object_prototype);
737  JSObject::ForceSetPrototype(generator_object_prototype, iterator_prototype);
738  Handle<JSObject> generator_function_prototype =
739      factory()->NewJSObject(isolate()->object_function(), TENURED);
740  JSObject::ForceSetPrototype(generator_function_prototype, empty);
741
742  JSObject::AddProperty(
743      generator_function_prototype, factory()->to_string_tag_symbol(),
744      factory()->NewStringFromAsciiChecked("GeneratorFunction"),
745      static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
746  JSObject::AddProperty(generator_function_prototype,
747                        factory()->prototype_string(),
748                        generator_object_prototype,
749                        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
750
751  JSObject::AddProperty(generator_object_prototype,
752                        factory()->constructor_string(),
753                        generator_function_prototype,
754                        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
755  JSObject::AddProperty(generator_object_prototype,
756                        factory()->to_string_tag_symbol(),
757                        factory()->NewStringFromAsciiChecked("Generator"),
758                        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
759  SimpleInstallFunction(generator_object_prototype, "next",
760                        Builtins::kGeneratorPrototypeNext, 1, true);
761  SimpleInstallFunction(generator_object_prototype, "return",
762                        Builtins::kGeneratorPrototypeReturn, 1, true);
763  SimpleInstallFunction(generator_object_prototype, "throw",
764                        Builtins::kGeneratorPrototypeThrow, 1, true);
765
766  // Internal version of generator_prototype_next, flagged as non-native such
767  // that it doesn't show up in Error traces.
768  Handle<JSFunction> generator_next_internal =
769      SimpleCreateFunction(isolate(), factory()->next_string(),
770                           Builtins::kGeneratorPrototypeNext, 1, true);
771  generator_next_internal->shared()->set_native(false);
772  native_context()->set_generator_next_internal(*generator_next_internal);
773
774  // Create maps for generator functions and their prototypes.  Store those
775  // maps in the native context. The "prototype" property descriptor is
776  // writable, non-enumerable, and non-configurable (as per ES6 draft
777  // 04-14-15, section 25.2.4.3).
778  Handle<Map> strict_function_map(strict_function_map_writable_prototype_);
779  // Generator functions do not have "caller" or "arguments" accessors.
780  Handle<Map> generator_function_map =
781      Map::Copy(strict_function_map, "GeneratorFunction");
782  generator_function_map->set_is_constructor(false);
783  Map::SetPrototype(generator_function_map, generator_function_prototype);
784  native_context()->set_generator_function_map(*generator_function_map);
785
786  Handle<JSFunction> object_function(native_context()->object_function());
787  Handle<Map> generator_object_prototype_map = Map::Create(isolate(), 0);
788  Map::SetPrototype(generator_object_prototype_map, generator_object_prototype);
789  native_context()->set_generator_object_prototype_map(
790      *generator_object_prototype_map);
791}
792
793void Genesis::CreateAsyncIteratorMaps() {
794  // %AsyncIteratorPrototype%
795  // proposal-async-iteration/#sec-asynciteratorprototype
796  Handle<JSObject> async_iterator_prototype =
797      factory()->NewJSObject(isolate()->object_function(), TENURED);
798
799  Handle<JSFunction> async_iterator_prototype_iterator = SimpleCreateFunction(
800      isolate(), factory()->NewStringFromAsciiChecked("[Symbol.asyncIterator]"),
801      Builtins::kReturnReceiver, 0, true);
802
803  JSObject::AddProperty(async_iterator_prototype,
804                        factory()->async_iterator_symbol(),
805                        async_iterator_prototype_iterator, DONT_ENUM);
806
807  // %AsyncFromSyncIteratorPrototype%
808  // proposal-async-iteration/#sec-%asyncfromsynciteratorprototype%-object
809  Handle<JSObject> async_from_sync_iterator_prototype =
810      factory()->NewJSObject(isolate()->object_function(), TENURED);
811  SimpleInstallFunction(async_from_sync_iterator_prototype,
812                        factory()->next_string(),
813                        Builtins::kAsyncFromSyncIteratorPrototypeNext, 1, true);
814  SimpleInstallFunction(
815      async_from_sync_iterator_prototype, factory()->return_string(),
816      Builtins::kAsyncFromSyncIteratorPrototypeReturn, 1, true);
817  SimpleInstallFunction(
818      async_from_sync_iterator_prototype, factory()->throw_string(),
819      Builtins::kAsyncFromSyncIteratorPrototypeThrow, 1, true);
820
821  JSObject::AddProperty(
822      async_from_sync_iterator_prototype, factory()->to_string_tag_symbol(),
823      factory()->NewStringFromAsciiChecked("Async-from-Sync Iterator"),
824      static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
825
826  JSObject::ForceSetPrototype(async_from_sync_iterator_prototype,
827                              async_iterator_prototype);
828
829  Handle<Map> async_from_sync_iterator_map = factory()->NewMap(
830      JS_ASYNC_FROM_SYNC_ITERATOR_TYPE, JSAsyncFromSyncIterator::kSize);
831  Map::SetPrototype(async_from_sync_iterator_map,
832                    async_from_sync_iterator_prototype);
833  native_context()->set_async_from_sync_iterator_map(
834      *async_from_sync_iterator_map);
835}
836
837void Genesis::CreateAsyncFunctionMaps(Handle<JSFunction> empty) {
838  // %AsyncFunctionPrototype% intrinsic
839  Handle<JSObject> async_function_prototype =
840      factory()->NewJSObject(isolate()->object_function(), TENURED);
841  JSObject::ForceSetPrototype(async_function_prototype, empty);
842
843  JSObject::AddProperty(async_function_prototype,
844                        factory()->to_string_tag_symbol(),
845                        factory()->NewStringFromAsciiChecked("AsyncFunction"),
846                        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
847
848  Handle<Map> strict_function_map(
849      native_context()->strict_function_without_prototype_map());
850  Handle<Map> async_function_map =
851      Map::Copy(strict_function_map, "AsyncFunction");
852  async_function_map->set_is_constructor(false);
853  Map::SetPrototype(async_function_map, async_function_prototype);
854  native_context()->set_async_function_map(*async_function_map);
855}
856
857void Genesis::CreateJSProxyMaps() {
858  // Allocate the different maps for all Proxy types.
859  // Next to the default proxy, we need maps indicating callable and
860  // constructable proxies.
861  Handle<Map> proxy_function_map =
862      Map::Copy(isolate()->sloppy_function_without_prototype_map(), "Proxy");
863  proxy_function_map->set_is_constructor(true);
864  native_context()->set_proxy_function_map(*proxy_function_map);
865
866  Handle<Map> proxy_map =
867      factory()->NewMap(JS_PROXY_TYPE, JSProxy::kSize, FAST_ELEMENTS);
868  proxy_map->set_dictionary_map(true);
869  native_context()->set_proxy_map(*proxy_map);
870
871  Handle<Map> proxy_callable_map = Map::Copy(proxy_map, "callable Proxy");
872  proxy_callable_map->set_is_callable();
873  native_context()->set_proxy_callable_map(*proxy_callable_map);
874  proxy_callable_map->SetConstructor(native_context()->function_function());
875
876  Handle<Map> proxy_constructor_map =
877      Map::Copy(proxy_callable_map, "constructor Proxy");
878  proxy_constructor_map->set_is_constructor(true);
879  native_context()->set_proxy_constructor_map(*proxy_constructor_map);
880}
881
882static void ReplaceAccessors(Handle<Map> map,
883                             Handle<String> name,
884                             PropertyAttributes attributes,
885                             Handle<AccessorPair> accessor_pair) {
886  DescriptorArray* descriptors = map->instance_descriptors();
887  int idx = descriptors->SearchWithCache(map->GetIsolate(), *name, *map);
888  Descriptor d = Descriptor::AccessorConstant(name, accessor_pair, attributes);
889  descriptors->Replace(idx, &d);
890}
891
892void Genesis::AddRestrictedFunctionProperties(Handle<JSFunction> empty) {
893  PropertyAttributes rw_attribs = static_cast<PropertyAttributes>(DONT_ENUM);
894  Handle<JSFunction> thrower = GetRestrictedFunctionPropertiesThrower();
895  Handle<AccessorPair> accessors = factory()->NewAccessorPair();
896  accessors->set_getter(*thrower);
897  accessors->set_setter(*thrower);
898
899  Handle<Map> map(empty->map());
900  ReplaceAccessors(map, factory()->arguments_string(), rw_attribs, accessors);
901  ReplaceAccessors(map, factory()->caller_string(), rw_attribs, accessors);
902}
903
904
905static void AddToWeakNativeContextList(Context* context) {
906  DCHECK(context->IsNativeContext());
907  Isolate* isolate = context->GetIsolate();
908  Heap* heap = isolate->heap();
909#ifdef DEBUG
910  { // NOLINT
911    DCHECK(context->next_context_link()->IsUndefined(isolate));
912    // Check that context is not in the list yet.
913    for (Object* current = heap->native_contexts_list();
914         !current->IsUndefined(isolate);
915         current = Context::cast(current)->next_context_link()) {
916      DCHECK(current != context);
917    }
918  }
919#endif
920  context->set(Context::NEXT_CONTEXT_LINK, heap->native_contexts_list(),
921               UPDATE_WEAK_WRITE_BARRIER);
922  heap->set_native_contexts_list(context);
923}
924
925
926void Genesis::CreateRoots() {
927  // Allocate the native context FixedArray first and then patch the
928  // closure and extension object later (we need the empty function
929  // and the global object, but in order to create those, we need the
930  // native context).
931  native_context_ = factory()->NewNativeContext();
932  AddToWeakNativeContextList(*native_context());
933  isolate()->set_context(*native_context());
934
935  // Allocate the message listeners object.
936  {
937    Handle<TemplateList> list = TemplateList::New(isolate(), 1);
938    native_context()->set_message_listeners(*list);
939  }
940}
941
942
943void Genesis::InstallGlobalThisBinding() {
944  Handle<ScriptContextTable> script_contexts(
945      native_context()->script_context_table());
946  Handle<ScopeInfo> scope_info = ScopeInfo::CreateGlobalThisBinding(isolate());
947  Handle<JSFunction> closure(native_context()->closure());
948  Handle<Context> context = factory()->NewScriptContext(closure, scope_info);
949
950  // Go ahead and hook it up while we're at it.
951  int slot = scope_info->ReceiverContextSlotIndex();
952  DCHECK_EQ(slot, Context::MIN_CONTEXT_SLOTS);
953  context->set(slot, native_context()->global_proxy());
954
955  Handle<ScriptContextTable> new_script_contexts =
956      ScriptContextTable::Extend(script_contexts, context);
957  native_context()->set_script_context_table(*new_script_contexts);
958}
959
960
961Handle<JSGlobalObject> Genesis::CreateNewGlobals(
962    v8::Local<v8::ObjectTemplate> global_proxy_template,
963    Handle<JSGlobalProxy> global_proxy) {
964  // The argument global_proxy_template aka data is an ObjectTemplateInfo.
965  // It has a constructor pointer that points at global_constructor which is a
966  // FunctionTemplateInfo.
967  // The global_proxy_constructor is used to (re)initialize the
968  // global_proxy. The global_proxy_constructor also has a prototype_template
969  // pointer that points at js_global_object_template which is an
970  // ObjectTemplateInfo.
971  // That in turn has a constructor pointer that points at
972  // js_global_object_constructor which is a FunctionTemplateInfo.
973  // js_global_object_constructor is used to make js_global_object_function
974  // js_global_object_function is used to make the new global_object.
975  //
976  // --- G l o b a l ---
977  // Step 1: Create a fresh JSGlobalObject.
978  Handle<JSFunction> js_global_object_function;
979  Handle<ObjectTemplateInfo> js_global_object_template;
980  if (!global_proxy_template.IsEmpty()) {
981    // Get prototype template of the global_proxy_template.
982    Handle<ObjectTemplateInfo> data =
983        v8::Utils::OpenHandle(*global_proxy_template);
984    Handle<FunctionTemplateInfo> global_constructor =
985        Handle<FunctionTemplateInfo>(
986            FunctionTemplateInfo::cast(data->constructor()));
987    Handle<Object> proto_template(global_constructor->prototype_template(),
988                                  isolate());
989    if (!proto_template->IsUndefined(isolate())) {
990      js_global_object_template =
991          Handle<ObjectTemplateInfo>::cast(proto_template);
992    }
993  }
994
995  if (js_global_object_template.is_null()) {
996    Handle<String> name = Handle<String>(heap()->empty_string());
997    Handle<Code> code = isolate()->builtins()->Illegal();
998    Handle<JSObject> prototype =
999        factory()->NewFunctionPrototype(isolate()->object_function());
1000    js_global_object_function = factory()->NewFunction(
1001        name, code, prototype, JS_GLOBAL_OBJECT_TYPE, JSGlobalObject::kSize);
1002#ifdef DEBUG
1003    LookupIterator it(prototype, factory()->constructor_string(),
1004                      LookupIterator::OWN_SKIP_INTERCEPTOR);
1005    Handle<Object> value = Object::GetProperty(&it).ToHandleChecked();
1006    DCHECK(it.IsFound());
1007    DCHECK_EQ(*isolate()->object_function(), *value);
1008#endif
1009  } else {
1010    Handle<FunctionTemplateInfo> js_global_object_constructor(
1011        FunctionTemplateInfo::cast(js_global_object_template->constructor()));
1012    js_global_object_function = ApiNatives::CreateApiFunction(
1013        isolate(), js_global_object_constructor, factory()->the_hole_value(),
1014        ApiNatives::GlobalObjectType);
1015  }
1016
1017  js_global_object_function->initial_map()->set_is_prototype_map(true);
1018  js_global_object_function->initial_map()->set_dictionary_map(true);
1019  Handle<JSGlobalObject> global_object =
1020      factory()->NewJSGlobalObject(js_global_object_function);
1021
1022  // Step 2: (re)initialize the global proxy object.
1023  Handle<JSFunction> global_proxy_function;
1024  if (global_proxy_template.IsEmpty()) {
1025    Handle<String> name = Handle<String>(heap()->empty_string());
1026    Handle<Code> code = isolate()->builtins()->Illegal();
1027    global_proxy_function =
1028        factory()->NewFunction(name, code, JS_GLOBAL_PROXY_TYPE,
1029                               JSGlobalProxy::SizeWithInternalFields(0));
1030  } else {
1031    Handle<ObjectTemplateInfo> data =
1032        v8::Utils::OpenHandle(*global_proxy_template);
1033    Handle<FunctionTemplateInfo> global_constructor(
1034            FunctionTemplateInfo::cast(data->constructor()));
1035    global_proxy_function = ApiNatives::CreateApiFunction(
1036        isolate(), global_constructor, factory()->the_hole_value(),
1037        ApiNatives::GlobalProxyType);
1038  }
1039  Handle<String> global_name = factory()->global_string();
1040  global_proxy_function->shared()->set_instance_class_name(*global_name);
1041  global_proxy_function->initial_map()->set_is_access_check_needed(true);
1042  global_proxy_function->initial_map()->set_has_hidden_prototype(true);
1043  native_context()->set_global_proxy_function(*global_proxy_function);
1044
1045  // Set global_proxy.__proto__ to js_global after ConfigureGlobalObjects
1046  // Return the global proxy.
1047
1048  factory()->ReinitializeJSGlobalProxy(global_proxy, global_proxy_function);
1049
1050  // Set the native context for the global object.
1051  global_object->set_native_context(*native_context());
1052  global_object->set_global_proxy(*global_proxy);
1053  // Set the native context of the global proxy.
1054  global_proxy->set_native_context(*native_context());
1055  // Set the global proxy of the native context. If the native context has been
1056  // deserialized, the global proxy is already correctly set up by the
1057  // deserializer. Otherwise it's undefined.
1058  DCHECK(native_context()
1059             ->get(Context::GLOBAL_PROXY_INDEX)
1060             ->IsUndefined(isolate()) ||
1061         native_context()->global_proxy() == *global_proxy);
1062  native_context()->set_global_proxy(*global_proxy);
1063
1064  return global_object;
1065}
1066
1067void Genesis::HookUpGlobalProxy(Handle<JSGlobalProxy> global_proxy) {
1068  // Re-initialize the global proxy with the global proxy function from the
1069  // snapshot, and then set up the link to the native context.
1070  Handle<JSFunction> global_proxy_function(
1071      native_context()->global_proxy_function());
1072  factory()->ReinitializeJSGlobalProxy(global_proxy, global_proxy_function);
1073  Handle<JSObject> global_object(
1074      JSObject::cast(native_context()->global_object()));
1075  JSObject::ForceSetPrototype(global_proxy, global_object);
1076  global_proxy->set_native_context(*native_context());
1077  DCHECK(native_context()->global_proxy() == *global_proxy);
1078}
1079
1080void Genesis::HookUpGlobalObject(Handle<JSGlobalObject> global_object) {
1081  Handle<JSGlobalObject> global_object_from_snapshot(
1082      JSGlobalObject::cast(native_context()->extension()));
1083  native_context()->set_extension(*global_object);
1084  native_context()->set_security_token(*global_object);
1085
1086  TransferNamedProperties(global_object_from_snapshot, global_object);
1087  TransferIndexedProperties(global_object_from_snapshot, global_object);
1088}
1089
1090static void InstallWithIntrinsicDefaultProto(Isolate* isolate,
1091                                             Handle<JSFunction> function,
1092                                             int context_index) {
1093  Handle<Smi> index(Smi::FromInt(context_index), isolate);
1094  JSObject::AddProperty(
1095      function, isolate->factory()->native_context_index_symbol(), index, NONE);
1096  isolate->native_context()->set(context_index, *function);
1097}
1098
1099static void InstallError(Isolate* isolate, Handle<JSObject> global,
1100                         Handle<String> name, int context_index) {
1101  Factory* factory = isolate->factory();
1102
1103  Handle<JSFunction> error_fun =
1104      InstallFunction(global, name, JS_ERROR_TYPE, JSObject::kHeaderSize,
1105                      isolate->initial_object_prototype(),
1106                      Builtins::kErrorConstructor, DONT_ENUM);
1107  error_fun->shared()->set_instance_class_name(*factory->Error_string());
1108  error_fun->shared()->DontAdaptArguments();
1109  error_fun->shared()->set_construct_stub(
1110      *isolate->builtins()->ErrorConstructor());
1111  error_fun->shared()->set_length(1);
1112
1113  if (context_index == Context::ERROR_FUNCTION_INDEX) {
1114    SimpleInstallFunction(error_fun, "captureStackTrace",
1115                          Builtins::kErrorCaptureStackTrace, 2, false);
1116  }
1117
1118  InstallWithIntrinsicDefaultProto(isolate, error_fun, context_index);
1119
1120  {
1121    Handle<JSObject> prototype =
1122        factory->NewJSObject(isolate->object_function(), TENURED);
1123
1124    JSObject::AddProperty(prototype, factory->name_string(), name, DONT_ENUM);
1125    JSObject::AddProperty(prototype, factory->message_string(),
1126                          factory->empty_string(), DONT_ENUM);
1127    JSObject::AddProperty(prototype, factory->constructor_string(), error_fun,
1128                          DONT_ENUM);
1129
1130    if (context_index == Context::ERROR_FUNCTION_INDEX) {
1131      Handle<JSFunction> to_string_fun =
1132          SimpleInstallFunction(prototype, factory->toString_string(),
1133                                Builtins::kErrorPrototypeToString, 0, true);
1134      isolate->native_context()->set_error_to_string(*to_string_fun);
1135    } else {
1136      DCHECK(isolate->native_context()->error_to_string()->IsJSFunction());
1137
1138      InstallFunction(prototype, isolate->error_to_string(),
1139                      factory->toString_string(), DONT_ENUM);
1140
1141      Handle<JSFunction> global_error = isolate->error_function();
1142      CHECK(JSReceiver::SetPrototype(error_fun, global_error, false,
1143                                     Object::THROW_ON_ERROR)
1144                .FromMaybe(false));
1145      CHECK(JSReceiver::SetPrototype(prototype,
1146                                     handle(global_error->prototype(), isolate),
1147                                     false, Object::THROW_ON_ERROR)
1148                .FromMaybe(false));
1149    }
1150
1151    Accessors::FunctionSetPrototype(error_fun, prototype).Assert();
1152  }
1153
1154  Handle<Map> initial_map(error_fun->initial_map());
1155  Map::EnsureDescriptorSlack(initial_map, 1);
1156
1157  PropertyAttributes attribs = DONT_ENUM;
1158  Handle<AccessorInfo> error_stack =
1159      Accessors::ErrorStackInfo(isolate, attribs);
1160  {
1161    Descriptor d = Descriptor::AccessorConstant(
1162        Handle<Name>(Name::cast(error_stack->name())), error_stack, attribs);
1163    initial_map->AppendDescriptor(&d);
1164  }
1165}
1166
1167static void InstallMakeError(Isolate* isolate, Handle<Code> code,
1168                             int context_index) {
1169  Handle<JSFunction> function =
1170      isolate->factory()->NewFunction(isolate->factory()->empty_string(), code,
1171                                      JS_OBJECT_TYPE, JSObject::kHeaderSize);
1172  function->shared()->DontAdaptArguments();
1173  isolate->native_context()->set(context_index, *function);
1174}
1175
1176// This is only called if we are not using snapshots.  The equivalent
1177// work in the snapshot case is done in HookUpGlobalObject.
1178void Genesis::InitializeGlobal(Handle<JSGlobalObject> global_object,
1179                               Handle<JSFunction> empty_function,
1180                               GlobalContextType context_type) {
1181  // --- N a t i v e   C o n t e x t ---
1182  // Use the empty function as closure (no scope info).
1183  native_context()->set_closure(*empty_function);
1184  native_context()->set_previous(NULL);
1185  // Set extension and global object.
1186  native_context()->set_extension(*global_object);
1187  // Security setup: Set the security token of the native context to the global
1188  // object. This makes the security check between two different contexts fail
1189  // by default even in case of global object reinitialization.
1190  native_context()->set_security_token(*global_object);
1191
1192  Isolate* isolate = global_object->GetIsolate();
1193  Factory* factory = isolate->factory();
1194
1195  native_context()->set_osr_code_table(*factory->empty_fixed_array());
1196
1197  Handle<ScriptContextTable> script_context_table =
1198      factory->NewScriptContextTable();
1199  native_context()->set_script_context_table(*script_context_table);
1200  InstallGlobalThisBinding();
1201
1202  {  // --- O b j e c t ---
1203    Handle<String> object_name = factory->Object_string();
1204    Handle<JSFunction> object_function = isolate->object_function();
1205    JSObject::AddProperty(global_object, object_name, object_function,
1206                          DONT_ENUM);
1207
1208    SimpleInstallFunction(object_function, factory->assign_string(),
1209                          Builtins::kObjectAssign, 2, false);
1210    SimpleInstallFunction(object_function, "getOwnPropertyDescriptor",
1211                          Builtins::kObjectGetOwnPropertyDescriptor, 2, false);
1212    SimpleInstallFunction(object_function,
1213                          factory->getOwnPropertyDescriptors_string(),
1214                          Builtins::kObjectGetOwnPropertyDescriptors, 1, false);
1215    SimpleInstallFunction(object_function, "getOwnPropertyNames",
1216                          Builtins::kObjectGetOwnPropertyNames, 1, false);
1217    SimpleInstallFunction(object_function, "getOwnPropertySymbols",
1218                          Builtins::kObjectGetOwnPropertySymbols, 1, false);
1219    SimpleInstallFunction(object_function, "is",
1220                          Builtins::kObjectIs, 2, true);
1221    SimpleInstallFunction(object_function, "preventExtensions",
1222                          Builtins::kObjectPreventExtensions, 1, false);
1223    SimpleInstallFunction(object_function, "seal",
1224                          Builtins::kObjectSeal, 1, false);
1225
1226    Handle<JSFunction> object_create =
1227        SimpleInstallFunction(object_function, factory->create_string(),
1228                              Builtins::kObjectCreate, 2, true);
1229    native_context()->set_object_create(*object_create);
1230
1231    Handle<JSFunction> object_define_properties = SimpleInstallFunction(
1232        object_function, "defineProperties",
1233        Builtins::kObjectDefineProperties, 2, true);
1234    native_context()->set_object_define_properties(*object_define_properties);
1235
1236    Handle<JSFunction> object_define_property = SimpleInstallFunction(
1237        object_function, factory->defineProperty_string(),
1238        Builtins::kObjectDefineProperty, 3, true);
1239    native_context()->set_object_define_property(*object_define_property);
1240
1241    Handle<JSFunction> object_freeze = SimpleInstallFunction(
1242        object_function, "freeze", Builtins::kObjectFreeze, 1, false);
1243    native_context()->set_object_freeze(*object_freeze);
1244
1245    Handle<JSFunction> object_get_prototype_of = SimpleInstallFunction(
1246        object_function, "getPrototypeOf", Builtins::kObjectGetPrototypeOf,
1247        1, false);
1248    native_context()->set_object_get_prototype_of(*object_get_prototype_of);
1249    SimpleInstallFunction(object_function, "setPrototypeOf",
1250                          Builtins::kObjectSetPrototypeOf, 2, false);
1251
1252    Handle<JSFunction> object_is_extensible = SimpleInstallFunction(
1253        object_function, "isExtensible", Builtins::kObjectIsExtensible,
1254        1, false);
1255    native_context()->set_object_is_extensible(*object_is_extensible);
1256
1257    Handle<JSFunction> object_is_frozen = SimpleInstallFunction(
1258        object_function, "isFrozen", Builtins::kObjectIsFrozen, 1, false);
1259    native_context()->set_object_is_frozen(*object_is_frozen);
1260
1261    Handle<JSFunction> object_is_sealed = SimpleInstallFunction(
1262        object_function, "isSealed", Builtins::kObjectIsSealed, 1, false);
1263    native_context()->set_object_is_sealed(*object_is_sealed);
1264
1265    Handle<JSFunction> object_keys = SimpleInstallFunction(
1266        object_function, "keys", Builtins::kObjectKeys, 1, false);
1267    native_context()->set_object_keys(*object_keys);
1268    SimpleInstallFunction(object_function, factory->entries_string(),
1269                          Builtins::kObjectEntries, 1, false);
1270    SimpleInstallFunction(object_function, factory->values_string(),
1271                          Builtins::kObjectValues, 1, false);
1272
1273    SimpleInstallFunction(isolate->initial_object_prototype(),
1274                          "__defineGetter__", Builtins::kObjectDefineGetter, 2,
1275                          true);
1276    SimpleInstallFunction(isolate->initial_object_prototype(),
1277                          "__defineSetter__", Builtins::kObjectDefineSetter, 2,
1278                          true);
1279    SimpleInstallFunction(isolate->initial_object_prototype(), "hasOwnProperty",
1280                          Builtins::kObjectHasOwnProperty, 1, true);
1281    SimpleInstallFunction(isolate->initial_object_prototype(),
1282                          "__lookupGetter__", Builtins::kObjectLookupGetter, 1,
1283                          true);
1284    SimpleInstallFunction(isolate->initial_object_prototype(),
1285                          "__lookupSetter__", Builtins::kObjectLookupSetter, 1,
1286                          true);
1287    SimpleInstallFunction(
1288        isolate->initial_object_prototype(), "propertyIsEnumerable",
1289        Builtins::kObjectPrototypePropertyIsEnumerable, 1, false);
1290
1291    SimpleInstallGetterSetter(isolate->initial_object_prototype(),
1292                              factory->proto_string(),
1293                              Builtins::kObjectPrototypeGetProto,
1294                              Builtins::kObjectPrototypeSetProto, DONT_ENUM);
1295  }
1296
1297  Handle<JSObject> global(native_context()->global_object());
1298
1299  {  // --- F u n c t i o n ---
1300    Handle<JSFunction> prototype = empty_function;
1301    Handle<JSFunction> function_fun =
1302        InstallFunction(global, "Function", JS_FUNCTION_TYPE, JSFunction::kSize,
1303                        prototype, Builtins::kFunctionConstructor);
1304    function_fun->set_prototype_or_initial_map(
1305        *sloppy_function_map_writable_prototype_);
1306    function_fun->shared()->DontAdaptArguments();
1307    function_fun->shared()->SetConstructStub(
1308        *isolate->builtins()->FunctionConstructor());
1309    function_fun->shared()->set_length(1);
1310    InstallWithIntrinsicDefaultProto(isolate, function_fun,
1311                                     Context::FUNCTION_FUNCTION_INDEX);
1312
1313    // Setup the methods on the %FunctionPrototype%.
1314    SimpleInstallFunction(prototype, factory->apply_string(),
1315                          Builtins::kFunctionPrototypeApply, 2, false);
1316    SimpleInstallFunction(prototype, factory->bind_string(),
1317                          Builtins::kFastFunctionPrototypeBind, 1, false);
1318    SimpleInstallFunction(prototype, factory->call_string(),
1319                          Builtins::kFunctionPrototypeCall, 1, false);
1320    SimpleInstallFunction(prototype, factory->toString_string(),
1321                          Builtins::kFunctionPrototypeToString, 0, false);
1322
1323    // Install the @@hasInstance function.
1324    Handle<JSFunction> has_instance = InstallFunction(
1325        prototype, factory->has_instance_symbol(), JS_OBJECT_TYPE,
1326        JSObject::kHeaderSize, MaybeHandle<JSObject>(),
1327        Builtins::kFunctionPrototypeHasInstance,
1328        static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY));
1329    has_instance->shared()->set_builtin_function_id(kFunctionHasInstance);
1330    native_context()->set_function_has_instance(*has_instance);
1331
1332    // Set the expected parameters for @@hasInstance to 1; required by builtin.
1333    has_instance->shared()->set_internal_formal_parameter_count(1);
1334
1335    // Set the length for the function to satisfy ECMA-262.
1336    has_instance->shared()->set_length(1);
1337
1338    // Install the "constructor" property on the %FunctionPrototype%.
1339    JSObject::AddProperty(prototype, factory->constructor_string(),
1340                          function_fun, DONT_ENUM);
1341
1342    sloppy_function_map_writable_prototype_->SetConstructor(*function_fun);
1343    strict_function_map_writable_prototype_->SetConstructor(*function_fun);
1344    class_function_map_->SetConstructor(*function_fun);
1345  }
1346
1347  {
1348    // --- A s y n c F r o m S y n c I t e r a t o r
1349    Handle<Code> code = isolate->builtins()->AsyncIteratorValueUnwrap();
1350    Handle<SharedFunctionInfo> info =
1351        factory->NewSharedFunctionInfo(factory->empty_string(), code, false);
1352    info->set_internal_formal_parameter_count(1);
1353    info->set_length(1);
1354    native_context()->set_async_iterator_value_unwrap_shared_fun(*info);
1355  }
1356
1357  {  // --- A r r a y ---
1358    Handle<JSFunction> array_function =
1359        InstallFunction(global, "Array", JS_ARRAY_TYPE, JSArray::kSize,
1360                        isolate->initial_object_prototype(),
1361                        Builtins::kArrayCode);
1362    array_function->shared()->DontAdaptArguments();
1363    array_function->shared()->set_builtin_function_id(kArrayCode);
1364
1365    // This seems a bit hackish, but we need to make sure Array.length
1366    // is 1.
1367    array_function->shared()->set_length(1);
1368
1369    Handle<Map> initial_map(array_function->initial_map());
1370
1371    // This assert protects an optimization in
1372    // HGraphBuilder::JSArrayBuilder::EmitMapCode()
1373    DCHECK(initial_map->elements_kind() == GetInitialFastElementsKind());
1374    Map::EnsureDescriptorSlack(initial_map, 1);
1375
1376    PropertyAttributes attribs = static_cast<PropertyAttributes>(
1377        DONT_ENUM | DONT_DELETE);
1378
1379    Handle<AccessorInfo> array_length =
1380        Accessors::ArrayLengthInfo(isolate, attribs);
1381    {  // Add length.
1382      Descriptor d = Descriptor::AccessorConstant(
1383          Handle<Name>(Name::cast(array_length->name())), array_length,
1384          attribs);
1385      initial_map->AppendDescriptor(&d);
1386    }
1387
1388    InstallWithIntrinsicDefaultProto(isolate, array_function,
1389                                     Context::ARRAY_FUNCTION_INDEX);
1390    InstallSpeciesGetter(array_function);
1391
1392    // Cache the array maps, needed by ArrayConstructorStub
1393    CacheInitialJSArrayMaps(native_context(), initial_map);
1394    ArrayConstructorStub array_constructor_stub(isolate);
1395    Handle<Code> code = array_constructor_stub.GetCode();
1396    array_function->shared()->SetConstructStub(*code);
1397
1398    Handle<JSFunction> is_arraylike = SimpleInstallFunction(
1399        array_function, isolate->factory()->InternalizeUtf8String("isArray"),
1400        Builtins::kArrayIsArray, 1, true);
1401    native_context()->set_is_arraylike(*is_arraylike);
1402  }
1403
1404  {  // --- A r r a y I t e r a t o r ---
1405    Handle<JSObject> iterator_prototype(
1406        native_context()->initial_iterator_prototype());
1407
1408    Handle<JSObject> array_iterator_prototype =
1409        factory->NewJSObject(isolate->object_function(), TENURED);
1410    JSObject::ForceSetPrototype(array_iterator_prototype, iterator_prototype);
1411
1412    JSObject::AddProperty(
1413        array_iterator_prototype, factory->to_string_tag_symbol(),
1414        factory->ArrayIterator_string(),
1415        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
1416
1417    Handle<JSFunction> next = InstallFunction(
1418        array_iterator_prototype, "next", JS_OBJECT_TYPE, JSObject::kHeaderSize,
1419        MaybeHandle<JSObject>(), Builtins::kArrayIteratorPrototypeNext);
1420    next->shared()->set_builtin_function_id(kArrayIteratorNext);
1421
1422    // Set the expected parameters for %ArrayIteratorPrototype%.next to 0 (not
1423    // including the receiver), as required by the builtin.
1424    next->shared()->set_internal_formal_parameter_count(0);
1425
1426    // Set the length for the function to satisfy ECMA-262.
1427    next->shared()->set_length(0);
1428
1429    Handle<JSFunction> array_iterator_function = CreateFunction(
1430        isolate, factory->ArrayIterator_string(),
1431        JS_FAST_ARRAY_VALUE_ITERATOR_TYPE, JSArrayIterator::kSize,
1432        array_iterator_prototype, Builtins::kIllegal);
1433    array_iterator_function->shared()->set_native(false);
1434    array_iterator_function->shared()->set_instance_class_name(
1435        isolate->heap()->ArrayIterator_string());
1436
1437    native_context()->set_initial_array_iterator_prototype(
1438        *array_iterator_prototype);
1439    native_context()->set_initial_array_iterator_prototype_map(
1440        array_iterator_prototype->map());
1441
1442    Handle<Map> initial_map(array_iterator_function->initial_map(), isolate);
1443
1444#define ARRAY_ITERATOR_LIST(V)                                              \
1445  V(TYPED_ARRAY, KEY, typed_array, key)                                     \
1446  V(FAST_ARRAY, KEY, fast_array, key)                                       \
1447  V(GENERIC_ARRAY, KEY, array, key)                                         \
1448  V(UINT8_ARRAY, KEY_VALUE, uint8_array, key_value)                         \
1449  V(INT8_ARRAY, KEY_VALUE, int8_array, key_value)                           \
1450  V(UINT16_ARRAY, KEY_VALUE, uint16_array, key_value)                       \
1451  V(INT16_ARRAY, KEY_VALUE, int16_array, key_value)                         \
1452  V(UINT32_ARRAY, KEY_VALUE, uint32_array, key_value)                       \
1453  V(INT32_ARRAY, KEY_VALUE, int32_array, key_value)                         \
1454  V(FLOAT32_ARRAY, KEY_VALUE, float32_array, key_value)                     \
1455  V(FLOAT64_ARRAY, KEY_VALUE, float64_array, key_value)                     \
1456  V(UINT8_CLAMPED_ARRAY, KEY_VALUE, uint8_clamped_array, key_value)         \
1457  V(FAST_SMI_ARRAY, KEY_VALUE, fast_smi_array, key_value)                   \
1458  V(FAST_HOLEY_SMI_ARRAY, KEY_VALUE, fast_holey_smi_array, key_value)       \
1459  V(FAST_ARRAY, KEY_VALUE, fast_array, key_value)                           \
1460  V(FAST_HOLEY_ARRAY, KEY_VALUE, fast_holey_array, key_value)               \
1461  V(FAST_DOUBLE_ARRAY, KEY_VALUE, fast_double_array, key_value)             \
1462  V(FAST_HOLEY_DOUBLE_ARRAY, KEY_VALUE, fast_holey_double_array, key_value) \
1463  V(GENERIC_ARRAY, KEY_VALUE, array, key_value)                             \
1464  V(UINT8_ARRAY, VALUE, uint8_array, value)                                 \
1465  V(INT8_ARRAY, VALUE, int8_array, value)                                   \
1466  V(UINT16_ARRAY, VALUE, uint16_array, value)                               \
1467  V(INT16_ARRAY, VALUE, int16_array, value)                                 \
1468  V(UINT32_ARRAY, VALUE, uint32_array, value)                               \
1469  V(INT32_ARRAY, VALUE, int32_array, value)                                 \
1470  V(FLOAT32_ARRAY, VALUE, float32_array, value)                             \
1471  V(FLOAT64_ARRAY, VALUE, float64_array, value)                             \
1472  V(UINT8_CLAMPED_ARRAY, VALUE, uint8_clamped_array, value)                 \
1473  V(FAST_SMI_ARRAY, VALUE, fast_smi_array, value)                           \
1474  V(FAST_HOLEY_SMI_ARRAY, VALUE, fast_holey_smi_array, value)               \
1475  V(FAST_ARRAY, VALUE, fast_array, value)                                   \
1476  V(FAST_HOLEY_ARRAY, VALUE, fast_holey_array, value)                       \
1477  V(FAST_DOUBLE_ARRAY, VALUE, fast_double_array, value)                     \
1478  V(FAST_HOLEY_DOUBLE_ARRAY, VALUE, fast_holey_double_array, value)         \
1479  V(GENERIC_ARRAY, VALUE, array, value)
1480
1481#define CREATE_ARRAY_ITERATOR_MAP(PREFIX, SUFFIX, prefix, suffix)           \
1482  do {                                                                      \
1483    const InstanceType type = JS_##PREFIX##_##SUFFIX##_ITERATOR_TYPE;       \
1484    Handle<Map> map =                                                       \
1485        Map::Copy(initial_map, "JS_" #PREFIX "_" #SUFFIX "_ITERATOR_TYPE"); \
1486    map->set_instance_type(type);                                           \
1487    native_context()->set_##prefix##_##suffix##_iterator_map(*map);         \
1488  } while (0);
1489
1490    ARRAY_ITERATOR_LIST(CREATE_ARRAY_ITERATOR_MAP)
1491
1492#undef CREATE_ARRAY_ITERATOR_MAP
1493#undef ARRAY_ITERATOR_LIST
1494  }
1495
1496  {  // --- N u m b e r ---
1497    Handle<JSFunction> number_fun = InstallFunction(
1498        global, "Number", JS_VALUE_TYPE, JSValue::kSize,
1499        isolate->initial_object_prototype(), Builtins::kNumberConstructor);
1500    number_fun->shared()->DontAdaptArguments();
1501    number_fun->shared()->SetConstructStub(
1502        *isolate->builtins()->NumberConstructor_ConstructStub());
1503    number_fun->shared()->set_length(1);
1504    InstallWithIntrinsicDefaultProto(isolate, number_fun,
1505                                     Context::NUMBER_FUNCTION_INDEX);
1506
1507    // Create the %NumberPrototype%
1508    Handle<JSValue> prototype =
1509        Handle<JSValue>::cast(factory->NewJSObject(number_fun, TENURED));
1510    prototype->set_value(Smi::kZero);
1511    Accessors::FunctionSetPrototype(number_fun, prototype).Assert();
1512
1513    // Install the "constructor" property on the {prototype}.
1514    JSObject::AddProperty(prototype, factory->constructor_string(), number_fun,
1515                          DONT_ENUM);
1516
1517    // Install the Number.prototype methods.
1518    SimpleInstallFunction(prototype, "toExponential",
1519                          Builtins::kNumberPrototypeToExponential, 1, false);
1520    SimpleInstallFunction(prototype, "toFixed",
1521                          Builtins::kNumberPrototypeToFixed, 1, false);
1522    SimpleInstallFunction(prototype, "toPrecision",
1523                          Builtins::kNumberPrototypeToPrecision, 1, false);
1524    SimpleInstallFunction(prototype, "toString",
1525                          Builtins::kNumberPrototypeToString, 1, false);
1526    SimpleInstallFunction(prototype, "valueOf",
1527                          Builtins::kNumberPrototypeValueOf, 0, true);
1528
1529    // Install i18n fallback functions.
1530    SimpleInstallFunction(prototype, "toLocaleString",
1531                          Builtins::kNumberPrototypeToLocaleString, 0, false);
1532
1533    // Install the Number functions.
1534    SimpleInstallFunction(number_fun, "isFinite", Builtins::kNumberIsFinite, 1,
1535                          true);
1536    SimpleInstallFunction(number_fun, "isInteger", Builtins::kNumberIsInteger,
1537                          1, true);
1538    SimpleInstallFunction(number_fun, "isNaN", Builtins::kNumberIsNaN, 1, true);
1539    SimpleInstallFunction(number_fun, "isSafeInteger",
1540                          Builtins::kNumberIsSafeInteger, 1, true);
1541
1542    // Install Number.parseFloat and Global.parseFloat.
1543    Handle<JSFunction> parse_float_fun = SimpleInstallFunction(
1544        number_fun, "parseFloat", Builtins::kNumberParseFloat, 1, true);
1545    JSObject::AddProperty(global_object,
1546                          factory->NewStringFromAsciiChecked("parseFloat"),
1547                          parse_float_fun, DONT_ENUM);
1548
1549    // Install Number.parseInt and Global.parseInt.
1550    Handle<JSFunction> parse_int_fun = SimpleInstallFunction(
1551        number_fun, "parseInt", Builtins::kNumberParseInt, 2, true);
1552    JSObject::AddProperty(global_object,
1553                          factory->NewStringFromAsciiChecked("parseInt"),
1554                          parse_int_fun, DONT_ENUM);
1555  }
1556
1557  {  // --- B o o l e a n ---
1558    Handle<JSFunction> boolean_fun =
1559        InstallFunction(global, "Boolean", JS_VALUE_TYPE, JSValue::kSize,
1560                        isolate->initial_object_prototype(),
1561                        Builtins::kBooleanConstructor);
1562    boolean_fun->shared()->DontAdaptArguments();
1563    boolean_fun->shared()->SetConstructStub(
1564        *isolate->builtins()->BooleanConstructor_ConstructStub());
1565    boolean_fun->shared()->set_length(1);
1566    InstallWithIntrinsicDefaultProto(isolate, boolean_fun,
1567                                     Context::BOOLEAN_FUNCTION_INDEX);
1568
1569    // Create the %BooleanPrototype%
1570    Handle<JSValue> prototype =
1571        Handle<JSValue>::cast(factory->NewJSObject(boolean_fun, TENURED));
1572    prototype->set_value(isolate->heap()->false_value());
1573    Accessors::FunctionSetPrototype(boolean_fun, prototype).Assert();
1574
1575    // Install the "constructor" property on the {prototype}.
1576    JSObject::AddProperty(prototype, factory->constructor_string(), boolean_fun,
1577                          DONT_ENUM);
1578
1579    // Install the Boolean.prototype methods.
1580    SimpleInstallFunction(prototype, "toString",
1581                          Builtins::kBooleanPrototypeToString, 0, true);
1582    SimpleInstallFunction(prototype, "valueOf",
1583                          Builtins::kBooleanPrototypeValueOf, 0, true);
1584  }
1585
1586  {  // --- S t r i n g ---
1587    Handle<JSFunction> string_fun = InstallFunction(
1588        global, "String", JS_VALUE_TYPE, JSValue::kSize,
1589        isolate->initial_object_prototype(), Builtins::kStringConstructor);
1590    string_fun->shared()->SetConstructStub(
1591        *isolate->builtins()->StringConstructor_ConstructStub());
1592    string_fun->shared()->DontAdaptArguments();
1593    string_fun->shared()->set_length(1);
1594    InstallWithIntrinsicDefaultProto(isolate, string_fun,
1595                                     Context::STRING_FUNCTION_INDEX);
1596
1597    Handle<Map> string_map =
1598        Handle<Map>(native_context()->string_function()->initial_map());
1599    string_map->set_elements_kind(FAST_STRING_WRAPPER_ELEMENTS);
1600    Map::EnsureDescriptorSlack(string_map, 1);
1601
1602    PropertyAttributes attribs = static_cast<PropertyAttributes>(
1603        DONT_ENUM | DONT_DELETE | READ_ONLY);
1604    Handle<AccessorInfo> string_length(
1605        Accessors::StringLengthInfo(isolate, attribs));
1606
1607    {  // Add length.
1608      Descriptor d = Descriptor::AccessorConstant(factory->length_string(),
1609                                                  string_length, attribs);
1610      string_map->AppendDescriptor(&d);
1611    }
1612
1613    // Install the String.fromCharCode function.
1614    SimpleInstallFunction(string_fun, "fromCharCode",
1615                          Builtins::kStringFromCharCode, 1, false);
1616
1617    // Install the String.fromCodePoint function.
1618    SimpleInstallFunction(string_fun, "fromCodePoint",
1619                          Builtins::kStringFromCodePoint, 1, false);
1620
1621    // Create the %StringPrototype%
1622    Handle<JSValue> prototype =
1623        Handle<JSValue>::cast(factory->NewJSObject(string_fun, TENURED));
1624    prototype->set_value(isolate->heap()->empty_string());
1625    Accessors::FunctionSetPrototype(string_fun, prototype).Assert();
1626
1627    // Install the "constructor" property on the {prototype}.
1628    JSObject::AddProperty(prototype, factory->constructor_string(), string_fun,
1629                          DONT_ENUM);
1630
1631    // Install the String.prototype methods.
1632    SimpleInstallFunction(prototype, "charAt", Builtins::kStringPrototypeCharAt,
1633                          1, true);
1634    SimpleInstallFunction(prototype, "charCodeAt",
1635                          Builtins::kStringPrototypeCharCodeAt, 1, true);
1636    SimpleInstallFunction(prototype, "endsWith",
1637                          Builtins::kStringPrototypeEndsWith, 1, false);
1638    SimpleInstallFunction(prototype, "includes",
1639                          Builtins::kStringPrototypeIncludes, 1, false);
1640    SimpleInstallFunction(prototype, "indexOf",
1641                          Builtins::kStringPrototypeIndexOf, 1, false);
1642    SimpleInstallFunction(prototype, "lastIndexOf",
1643                          Builtins::kStringPrototypeLastIndexOf, 1, false);
1644    SimpleInstallFunction(prototype, "localeCompare",
1645                          Builtins::kStringPrototypeLocaleCompare, 1, true);
1646    SimpleInstallFunction(prototype, "normalize",
1647                          Builtins::kStringPrototypeNormalize, 0, false);
1648    SimpleInstallFunction(prototype, "replace",
1649                          Builtins::kStringPrototypeReplace, 2, true);
1650    SimpleInstallFunction(prototype, "split", Builtins::kStringPrototypeSplit,
1651                          2, true);
1652    SimpleInstallFunction(prototype, "substr", Builtins::kStringPrototypeSubstr,
1653                          2, true);
1654    SimpleInstallFunction(prototype, "substring",
1655                          Builtins::kStringPrototypeSubstring, 2, true);
1656    SimpleInstallFunction(prototype, "startsWith",
1657                          Builtins::kStringPrototypeStartsWith, 1, false);
1658    SimpleInstallFunction(prototype, "toString",
1659                          Builtins::kStringPrototypeToString, 0, true);
1660    SimpleInstallFunction(prototype, "trim", Builtins::kStringPrototypeTrim, 0,
1661                          false);
1662    SimpleInstallFunction(prototype, "trimLeft",
1663                          Builtins::kStringPrototypeTrimLeft, 0, false);
1664    SimpleInstallFunction(prototype, "trimRight",
1665                          Builtins::kStringPrototypeTrimRight, 0, false);
1666    SimpleInstallFunction(prototype, "toLocaleLowerCase",
1667                          Builtins::kStringPrototypeToLocaleLowerCase, 0,
1668                          false);
1669    SimpleInstallFunction(prototype, "toLocaleUpperCase",
1670                          Builtins::kStringPrototypeToLocaleUpperCase, 0,
1671                          false);
1672    SimpleInstallFunction(prototype, "toLowerCase",
1673                          Builtins::kStringPrototypeToLowerCase, 0, false);
1674    SimpleInstallFunction(prototype, "toUpperCase",
1675                          Builtins::kStringPrototypeToUpperCase, 0, false);
1676    SimpleInstallFunction(prototype, "valueOf",
1677                          Builtins::kStringPrototypeValueOf, 0, true);
1678
1679    Handle<JSFunction> iterator = SimpleCreateFunction(
1680        isolate, factory->NewStringFromAsciiChecked("[Symbol.iterator]"),
1681        Builtins::kStringPrototypeIterator, 0, true);
1682    iterator->shared()->set_builtin_function_id(kStringIterator);
1683    JSObject::AddProperty(prototype, factory->iterator_symbol(), iterator,
1684                          static_cast<PropertyAttributes>(DONT_ENUM));
1685  }
1686
1687  {  // --- S t r i n g I t e r a t o r ---
1688    Handle<JSObject> iterator_prototype(
1689        native_context()->initial_iterator_prototype());
1690
1691    Handle<JSObject> string_iterator_prototype =
1692        factory->NewJSObject(isolate->object_function(), TENURED);
1693    JSObject::ForceSetPrototype(string_iterator_prototype, iterator_prototype);
1694
1695    JSObject::AddProperty(
1696        string_iterator_prototype, factory->to_string_tag_symbol(),
1697        factory->NewStringFromAsciiChecked("String Iterator"),
1698        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
1699
1700    Handle<JSFunction> next =
1701        InstallFunction(string_iterator_prototype, "next", JS_OBJECT_TYPE,
1702                        JSObject::kHeaderSize, MaybeHandle<JSObject>(),
1703                        Builtins::kStringIteratorPrototypeNext);
1704    next->shared()->set_builtin_function_id(kStringIteratorNext);
1705
1706    // Set the expected parameters for %StringIteratorPrototype%.next to 0 (not
1707    // including the receiver), as required by the builtin.
1708    next->shared()->set_internal_formal_parameter_count(0);
1709
1710    // Set the length for the function to satisfy ECMA-262.
1711    next->shared()->set_length(0);
1712
1713    Handle<JSFunction> string_iterator_function = CreateFunction(
1714        isolate, factory->NewStringFromAsciiChecked("StringIterator"),
1715        JS_STRING_ITERATOR_TYPE, JSStringIterator::kSize,
1716        string_iterator_prototype, Builtins::kIllegal);
1717    string_iterator_function->shared()->set_native(false);
1718    native_context()->set_string_iterator_map(
1719        string_iterator_function->initial_map());
1720  }
1721
1722  {
1723    // --- S y m b o l ---
1724    Handle<JSObject> prototype =
1725        factory->NewJSObject(isolate->object_function(), TENURED);
1726    Handle<JSFunction> symbol_fun =
1727        InstallFunction(global, "Symbol", JS_VALUE_TYPE, JSValue::kSize,
1728                        prototype, Builtins::kSymbolConstructor);
1729    symbol_fun->shared()->SetConstructStub(
1730        *isolate->builtins()->SymbolConstructor_ConstructStub());
1731    symbol_fun->shared()->set_length(0);
1732    symbol_fun->shared()->DontAdaptArguments();
1733    native_context()->set_symbol_function(*symbol_fun);
1734
1735    // Install the Symbol.for and Symbol.keyFor functions.
1736    SimpleInstallFunction(symbol_fun, "for", Builtins::kSymbolFor, 1, false);
1737    SimpleInstallFunction(symbol_fun, "keyFor", Builtins::kSymbolKeyFor, 1,
1738                          false);
1739
1740    // Install well-known symbols.
1741    InstallConstant(isolate, symbol_fun, "hasInstance",
1742                    factory->has_instance_symbol());
1743    InstallConstant(isolate, symbol_fun, "isConcatSpreadable",
1744                    factory->is_concat_spreadable_symbol());
1745    InstallConstant(isolate, symbol_fun, "iterator",
1746                    factory->iterator_symbol());
1747    InstallConstant(isolate, symbol_fun, "match", factory->match_symbol());
1748    InstallConstant(isolate, symbol_fun, "replace", factory->replace_symbol());
1749    InstallConstant(isolate, symbol_fun, "search", factory->search_symbol());
1750    InstallConstant(isolate, symbol_fun, "species", factory->species_symbol());
1751    InstallConstant(isolate, symbol_fun, "split", factory->split_symbol());
1752    InstallConstant(isolate, symbol_fun, "toPrimitive",
1753                    factory->to_primitive_symbol());
1754    InstallConstant(isolate, symbol_fun, "toStringTag",
1755                    factory->to_string_tag_symbol());
1756    InstallConstant(isolate, symbol_fun, "unscopables",
1757                    factory->unscopables_symbol());
1758
1759    // Install the @@toStringTag property on the {prototype}.
1760    JSObject::AddProperty(
1761        prototype, factory->to_string_tag_symbol(),
1762        factory->NewStringFromAsciiChecked("Symbol"),
1763        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
1764
1765    // Install the "constructor" property on the {prototype}.
1766    JSObject::AddProperty(prototype, factory->constructor_string(), symbol_fun,
1767                          DONT_ENUM);
1768
1769    // Install the Symbol.prototype methods.
1770    SimpleInstallFunction(prototype, "toString",
1771                          Builtins::kSymbolPrototypeToString, 0, true);
1772    SimpleInstallFunction(prototype, "valueOf",
1773                          Builtins::kSymbolPrototypeValueOf, 0, true);
1774
1775    // Install the @@toPrimitive function.
1776    Handle<JSFunction> to_primitive = InstallFunction(
1777        prototype, factory->to_primitive_symbol(), JS_OBJECT_TYPE,
1778        JSObject::kHeaderSize, MaybeHandle<JSObject>(),
1779        Builtins::kSymbolPrototypeToPrimitive,
1780        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
1781
1782    // Set the expected parameters for @@toPrimitive to 1; required by builtin.
1783    to_primitive->shared()->set_internal_formal_parameter_count(1);
1784
1785    // Set the length for the function to satisfy ECMA-262.
1786    to_primitive->shared()->set_length(1);
1787  }
1788
1789  {  // --- D a t e ---
1790    // Builtin functions for Date.prototype.
1791    Handle<JSObject> prototype =
1792        factory->NewJSObject(isolate->object_function(), TENURED);
1793    Handle<JSFunction> date_fun =
1794        InstallFunction(global, "Date", JS_DATE_TYPE, JSDate::kSize, prototype,
1795                        Builtins::kDateConstructor);
1796    InstallWithIntrinsicDefaultProto(isolate, date_fun,
1797                                     Context::DATE_FUNCTION_INDEX);
1798    date_fun->shared()->SetConstructStub(
1799        *isolate->builtins()->DateConstructor_ConstructStub());
1800    date_fun->shared()->set_length(7);
1801    date_fun->shared()->DontAdaptArguments();
1802
1803    // Install the Date.now, Date.parse and Date.UTC functions.
1804    SimpleInstallFunction(date_fun, "now", Builtins::kDateNow, 0, false);
1805    SimpleInstallFunction(date_fun, "parse", Builtins::kDateParse, 1, false);
1806    SimpleInstallFunction(date_fun, "UTC", Builtins::kDateUTC, 7, false);
1807
1808    // Install the "constructor" property on the {prototype}.
1809    JSObject::AddProperty(prototype, factory->constructor_string(), date_fun,
1810                          DONT_ENUM);
1811
1812    // Install the Date.prototype methods.
1813    SimpleInstallFunction(prototype, "toString",
1814                          Builtins::kDatePrototypeToString, 0, false);
1815    SimpleInstallFunction(prototype, "toDateString",
1816                          Builtins::kDatePrototypeToDateString, 0, false);
1817    SimpleInstallFunction(prototype, "toTimeString",
1818                          Builtins::kDatePrototypeToTimeString, 0, false);
1819    SimpleInstallFunction(prototype, "toISOString",
1820                          Builtins::kDatePrototypeToISOString, 0, false);
1821    Handle<JSFunction> to_utc_string =
1822        SimpleInstallFunction(prototype, "toUTCString",
1823                              Builtins::kDatePrototypeToUTCString, 0, false);
1824    InstallFunction(prototype, to_utc_string,
1825                    factory->InternalizeUtf8String("toGMTString"), DONT_ENUM);
1826    SimpleInstallFunction(prototype, "getDate", Builtins::kDatePrototypeGetDate,
1827                          0, true);
1828    SimpleInstallFunction(prototype, "setDate", Builtins::kDatePrototypeSetDate,
1829                          1, false);
1830    SimpleInstallFunction(prototype, "getDay", Builtins::kDatePrototypeGetDay,
1831                          0, true);
1832    SimpleInstallFunction(prototype, "getFullYear",
1833                          Builtins::kDatePrototypeGetFullYear, 0, true);
1834    SimpleInstallFunction(prototype, "setFullYear",
1835                          Builtins::kDatePrototypeSetFullYear, 3, false);
1836    SimpleInstallFunction(prototype, "getHours",
1837                          Builtins::kDatePrototypeGetHours, 0, true);
1838    SimpleInstallFunction(prototype, "setHours",
1839                          Builtins::kDatePrototypeSetHours, 4, false);
1840    SimpleInstallFunction(prototype, "getMilliseconds",
1841                          Builtins::kDatePrototypeGetMilliseconds, 0, true);
1842    SimpleInstallFunction(prototype, "setMilliseconds",
1843                          Builtins::kDatePrototypeSetMilliseconds, 1, false);
1844    SimpleInstallFunction(prototype, "getMinutes",
1845                          Builtins::kDatePrototypeGetMinutes, 0, true);
1846    SimpleInstallFunction(prototype, "setMinutes",
1847                          Builtins::kDatePrototypeSetMinutes, 3, false);
1848    SimpleInstallFunction(prototype, "getMonth",
1849                          Builtins::kDatePrototypeGetMonth, 0, true);
1850    SimpleInstallFunction(prototype, "setMonth",
1851                          Builtins::kDatePrototypeSetMonth, 2, false);
1852    SimpleInstallFunction(prototype, "getSeconds",
1853                          Builtins::kDatePrototypeGetSeconds, 0, true);
1854    SimpleInstallFunction(prototype, "setSeconds",
1855                          Builtins::kDatePrototypeSetSeconds, 2, false);
1856    SimpleInstallFunction(prototype, "getTime", Builtins::kDatePrototypeGetTime,
1857                          0, true);
1858    SimpleInstallFunction(prototype, "setTime", Builtins::kDatePrototypeSetTime,
1859                          1, false);
1860    SimpleInstallFunction(prototype, "getTimezoneOffset",
1861                          Builtins::kDatePrototypeGetTimezoneOffset, 0, true);
1862    SimpleInstallFunction(prototype, "getUTCDate",
1863                          Builtins::kDatePrototypeGetUTCDate, 0, true);
1864    SimpleInstallFunction(prototype, "setUTCDate",
1865                          Builtins::kDatePrototypeSetUTCDate, 1, false);
1866    SimpleInstallFunction(prototype, "getUTCDay",
1867                          Builtins::kDatePrototypeGetUTCDay, 0, true);
1868    SimpleInstallFunction(prototype, "getUTCFullYear",
1869                          Builtins::kDatePrototypeGetUTCFullYear, 0, true);
1870    SimpleInstallFunction(prototype, "setUTCFullYear",
1871                          Builtins::kDatePrototypeSetUTCFullYear, 3, false);
1872    SimpleInstallFunction(prototype, "getUTCHours",
1873                          Builtins::kDatePrototypeGetUTCHours, 0, true);
1874    SimpleInstallFunction(prototype, "setUTCHours",
1875                          Builtins::kDatePrototypeSetUTCHours, 4, false);
1876    SimpleInstallFunction(prototype, "getUTCMilliseconds",
1877                          Builtins::kDatePrototypeGetUTCMilliseconds, 0, true);
1878    SimpleInstallFunction(prototype, "setUTCMilliseconds",
1879                          Builtins::kDatePrototypeSetUTCMilliseconds, 1, false);
1880    SimpleInstallFunction(prototype, "getUTCMinutes",
1881                          Builtins::kDatePrototypeGetUTCMinutes, 0, true);
1882    SimpleInstallFunction(prototype, "setUTCMinutes",
1883                          Builtins::kDatePrototypeSetUTCMinutes, 3, false);
1884    SimpleInstallFunction(prototype, "getUTCMonth",
1885                          Builtins::kDatePrototypeGetUTCMonth, 0, true);
1886    SimpleInstallFunction(prototype, "setUTCMonth",
1887                          Builtins::kDatePrototypeSetUTCMonth, 2, false);
1888    SimpleInstallFunction(prototype, "getUTCSeconds",
1889                          Builtins::kDatePrototypeGetUTCSeconds, 0, true);
1890    SimpleInstallFunction(prototype, "setUTCSeconds",
1891                          Builtins::kDatePrototypeSetUTCSeconds, 2, false);
1892    SimpleInstallFunction(prototype, "valueOf", Builtins::kDatePrototypeValueOf,
1893                          0, true);
1894    SimpleInstallFunction(prototype, "getYear", Builtins::kDatePrototypeGetYear,
1895                          0, true);
1896    SimpleInstallFunction(prototype, "setYear", Builtins::kDatePrototypeSetYear,
1897                          1, false);
1898    SimpleInstallFunction(prototype, "toJSON", Builtins::kDatePrototypeToJson,
1899                          1, false);
1900
1901    // Install i18n fallback functions.
1902    SimpleInstallFunction(prototype, "toLocaleString",
1903                          Builtins::kDatePrototypeToString, 0, false);
1904    SimpleInstallFunction(prototype, "toLocaleDateString",
1905                          Builtins::kDatePrototypeToDateString, 0, false);
1906    SimpleInstallFunction(prototype, "toLocaleTimeString",
1907                          Builtins::kDatePrototypeToTimeString, 0, false);
1908
1909    // Install the @@toPrimitive function.
1910    Handle<JSFunction> to_primitive = InstallFunction(
1911        prototype, factory->to_primitive_symbol(), JS_OBJECT_TYPE,
1912        JSObject::kHeaderSize, MaybeHandle<JSObject>(),
1913        Builtins::kDatePrototypeToPrimitive,
1914        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
1915
1916    // Set the expected parameters for @@toPrimitive to 1; required by builtin.
1917    to_primitive->shared()->set_internal_formal_parameter_count(1);
1918
1919    // Set the length for the function to satisfy ECMA-262.
1920    to_primitive->shared()->set_length(1);
1921  }
1922
1923  {
1924    Handle<Code> code = isolate->builtins()->PromiseGetCapabilitiesExecutor();
1925    Handle<SharedFunctionInfo> info =
1926        factory->NewSharedFunctionInfo(factory->empty_string(), code, true);
1927    info->SetConstructStub(*isolate->builtins()->JSBuiltinsConstructStub());
1928    info->set_instance_class_name(isolate->heap()->Object_string());
1929    info->set_internal_formal_parameter_count(2);
1930    info->set_length(2);
1931    native_context()->set_promise_get_capabilities_executor_shared_fun(*info);
1932
1933    // %new_promise_capability(C, debugEvent)
1934    Handle<JSFunction> new_promise_capability =
1935        SimpleCreateFunction(isolate, factory->empty_string(),
1936                             Builtins::kNewPromiseCapability, 2, false);
1937    InstallWithIntrinsicDefaultProto(isolate, new_promise_capability,
1938                                     Context::NEW_PROMISE_CAPABILITY_INDEX);
1939  }
1940
1941  {  // -- P r o m i s e
1942    // Set catch prediction
1943    Handle<Code> promise_code = isolate->builtins()->PromiseConstructor();
1944    promise_code->set_is_promise_rejection(true);
1945
1946    Handle<JSObject> prototype =
1947        factory->NewJSObject(isolate->object_function(), TENURED);
1948    Handle<JSFunction> promise_fun =
1949        InstallFunction(global, "Promise", JS_PROMISE_TYPE, JSPromise::kSize,
1950                        prototype, Builtins::kPromiseConstructor);
1951    InstallWithIntrinsicDefaultProto(isolate, promise_fun,
1952                                     Context::PROMISE_FUNCTION_INDEX);
1953
1954    Handle<SharedFunctionInfo> shared(promise_fun->shared(), isolate);
1955    shared->SetConstructStub(*isolate->builtins()->JSBuiltinsConstructStub());
1956    shared->set_instance_class_name(isolate->heap()->Object_string());
1957    shared->set_internal_formal_parameter_count(1);
1958    shared->set_length(1);
1959
1960    // Install the "constructor" property on the {prototype}.
1961    JSObject::AddProperty(prototype, factory->constructor_string(), promise_fun,
1962                          DONT_ENUM);
1963
1964    // Install the @@toStringTag property on the {prototype}.
1965    JSObject::AddProperty(
1966        prototype, factory->to_string_tag_symbol(), factory->Promise_string(),
1967        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
1968
1969    Handle<JSFunction> promise_then =
1970        SimpleInstallFunction(prototype, isolate->factory()->then_string(),
1971                              Builtins::kPromiseThen, 2, true);
1972    InstallWithIntrinsicDefaultProto(isolate, promise_then,
1973                                     Context::PROMISE_THEN_INDEX);
1974
1975    Handle<JSFunction> promise_catch = SimpleInstallFunction(
1976        prototype, "catch", Builtins::kPromiseCatch, 1, true, DONT_ENUM);
1977    InstallWithIntrinsicDefaultProto(isolate, promise_catch,
1978                                     Context::PROMISE_CATCH_INDEX);
1979
1980    InstallSpeciesGetter(promise_fun);
1981
1982    SimpleInstallFunction(promise_fun, "resolve", Builtins::kPromiseResolve, 1,
1983                          true, DONT_ENUM);
1984
1985    SimpleInstallFunction(promise_fun, "reject", Builtins::kPromiseReject, 1,
1986                          true, DONT_ENUM);
1987
1988    Handle<Map> prototype_map(prototype->map());
1989    Map::SetShouldBeFastPrototypeMap(prototype_map, true, isolate);
1990
1991    // Store the initial Promise.prototype map. This is used in fast-path
1992    // checks. Do not alter the prototype after this point.
1993    native_context()->set_promise_prototype_map(*prototype_map);
1994
1995    {  // Internal: PromiseInternalConstructor
1996       // Also exposed as extrasUtils.createPromise.
1997      Handle<JSFunction> function =
1998          SimpleCreateFunction(isolate, factory->empty_string(),
1999                               Builtins::kPromiseInternalConstructor, 1, true);
2000      function->shared()->set_native(false);
2001      InstallWithIntrinsicDefaultProto(
2002          isolate, function, Context::PROMISE_INTERNAL_CONSTRUCTOR_INDEX);
2003    }
2004
2005    {  // Internal: IsPromise
2006      Handle<JSFunction> function = SimpleCreateFunction(
2007          isolate, factory->empty_string(), Builtins::kIsPromise, 1, false);
2008      InstallWithIntrinsicDefaultProto(isolate, function,
2009                                       Context::IS_PROMISE_INDEX);
2010    }
2011
2012    {  // Internal: ResolvePromise
2013       // Also exposed as extrasUtils.resolvePromise.
2014      Handle<JSFunction> function = SimpleCreateFunction(
2015          isolate, factory->empty_string(), Builtins::kResolvePromise, 2, true);
2016      function->shared()->set_native(false);
2017      InstallWithIntrinsicDefaultProto(isolate, function,
2018                                       Context::PROMISE_RESOLVE_INDEX);
2019    }
2020
2021    {  // Internal: PromiseHandle
2022      Handle<JSFunction> function = SimpleCreateFunction(
2023          isolate, factory->empty_string(), Builtins::kPromiseHandle, 5, false);
2024      InstallWithIntrinsicDefaultProto(isolate, function,
2025                                       Context::PROMISE_HANDLE_INDEX);
2026      // Set up catch prediction
2027      Handle<Code> promise_handle = isolate->builtins()->PromiseHandle();
2028      promise_handle->set_is_promise_rejection(true);
2029    }
2030
2031    {  // Internal: PromiseHandleReject
2032      Handle<JSFunction> function =
2033          SimpleCreateFunction(isolate, factory->empty_string(),
2034                               Builtins::kPromiseHandleReject, 3, false);
2035      InstallWithIntrinsicDefaultProto(isolate, function,
2036                                       Context::PROMISE_HANDLE_REJECT_INDEX);
2037      // Set up catch prediction
2038      Handle<Code> promise_handle = isolate->builtins()->PromiseHandleReject();
2039      promise_handle->set_is_exception_caught(true);
2040    }
2041
2042    {  // Internal: InternalPromiseReject
2043      Handle<JSFunction> function =
2044          SimpleCreateFunction(isolate, factory->empty_string(),
2045                               Builtins::kInternalPromiseReject, 3, true);
2046      function->shared()->set_native(false);
2047      InstallWithIntrinsicDefaultProto(isolate, function,
2048                                       Context::PROMISE_INTERNAL_REJECT_INDEX);
2049    }
2050
2051    {
2052      Handle<Code> code =
2053          handle(isolate->builtins()->builtin(Builtins::kPromiseResolveClosure),
2054                 isolate);
2055      Handle<SharedFunctionInfo> info =
2056          factory->NewSharedFunctionInfo(factory->empty_string(), code, false);
2057      info->set_internal_formal_parameter_count(1);
2058      info->set_length(1);
2059      native_context()->set_promise_resolve_shared_fun(*info);
2060
2061      code =
2062          handle(isolate->builtins()->builtin(Builtins::kPromiseRejectClosure),
2063                 isolate);
2064      info =
2065          factory->NewSharedFunctionInfo(factory->empty_string(), code, false);
2066      info->set_internal_formal_parameter_count(1);
2067      info->set_length(1);
2068      native_context()->set_promise_reject_shared_fun(*info);
2069    }
2070  }
2071
2072  {  // -- R e g E x p
2073    // Builtin functions for RegExp.prototype.
2074    Handle<JSObject> prototype =
2075        factory->NewJSObject(isolate->object_function(), TENURED);
2076    Handle<JSFunction> regexp_fun =
2077        InstallFunction(global, "RegExp", JS_REGEXP_TYPE, JSRegExp::kSize,
2078                        prototype, Builtins::kRegExpConstructor);
2079    InstallWithIntrinsicDefaultProto(isolate, regexp_fun,
2080                                     Context::REGEXP_FUNCTION_INDEX);
2081
2082    Handle<SharedFunctionInfo> shared(regexp_fun->shared(), isolate);
2083    shared->SetConstructStub(*isolate->builtins()->JSBuiltinsConstructStub());
2084    shared->set_instance_class_name(isolate->heap()->RegExp_string());
2085    shared->set_internal_formal_parameter_count(2);
2086    shared->set_length(2);
2087
2088    {
2089      // RegExp.prototype setup.
2090
2091      // Install the "constructor" property on the {prototype}.
2092      JSObject::AddProperty(prototype, factory->constructor_string(),
2093                            regexp_fun, DONT_ENUM);
2094
2095      {
2096        Handle<JSFunction> fun = SimpleInstallFunction(
2097            prototype, factory->exec_string(), Builtins::kRegExpPrototypeExec,
2098            1, true, DONT_ENUM);
2099        native_context()->set_regexp_exec_function(*fun);
2100      }
2101
2102      SimpleInstallGetter(prototype, factory->flags_string(),
2103                          Builtins::kRegExpPrototypeFlagsGetter, true);
2104      SimpleInstallGetter(prototype, factory->global_string(),
2105                          Builtins::kRegExpPrototypeGlobalGetter, true);
2106      SimpleInstallGetter(prototype, factory->ignoreCase_string(),
2107                          Builtins::kRegExpPrototypeIgnoreCaseGetter, true);
2108      SimpleInstallGetter(prototype, factory->multiline_string(),
2109                          Builtins::kRegExpPrototypeMultilineGetter, true);
2110      SimpleInstallGetter(prototype, factory->source_string(),
2111                          Builtins::kRegExpPrototypeSourceGetter, true);
2112      SimpleInstallGetter(prototype, factory->sticky_string(),
2113                          Builtins::kRegExpPrototypeStickyGetter, true);
2114      SimpleInstallGetter(prototype, factory->unicode_string(),
2115                          Builtins::kRegExpPrototypeUnicodeGetter, true);
2116
2117      SimpleInstallFunction(prototype, "compile",
2118                            Builtins::kRegExpPrototypeCompile, 2, true,
2119                            DONT_ENUM);
2120      SimpleInstallFunction(prototype, factory->toString_string(),
2121                            Builtins::kRegExpPrototypeToString, 0, false,
2122                            DONT_ENUM);
2123      SimpleInstallFunction(prototype, "test", Builtins::kRegExpPrototypeTest,
2124                            1, true, DONT_ENUM);
2125
2126      {
2127        Handle<JSFunction> fun = SimpleCreateFunction(
2128            isolate, factory->InternalizeUtf8String("[Symbol.match]"),
2129            Builtins::kRegExpPrototypeMatch, 1, true);
2130        InstallFunction(prototype, fun, factory->match_symbol(), DONT_ENUM);
2131      }
2132
2133      {
2134        Handle<JSFunction> fun = SimpleCreateFunction(
2135            isolate, factory->InternalizeUtf8String("[Symbol.replace]"),
2136            Builtins::kRegExpPrototypeReplace, 2, true);
2137        InstallFunction(prototype, fun, factory->replace_symbol(), DONT_ENUM);
2138      }
2139
2140      {
2141        Handle<JSFunction> fun = SimpleCreateFunction(
2142            isolate, factory->InternalizeUtf8String("[Symbol.search]"),
2143            Builtins::kRegExpPrototypeSearch, 1, true);
2144        InstallFunction(prototype, fun, factory->search_symbol(), DONT_ENUM);
2145      }
2146
2147      {
2148        Handle<JSFunction> fun = SimpleCreateFunction(
2149            isolate, factory->InternalizeUtf8String("[Symbol.split]"),
2150            Builtins::kRegExpPrototypeSplit, 2, true);
2151        InstallFunction(prototype, fun, factory->split_symbol(), DONT_ENUM);
2152      }
2153
2154      Handle<Map> prototype_map(prototype->map());
2155      Map::SetShouldBeFastPrototypeMap(prototype_map, true, isolate);
2156
2157      // Store the initial RegExp.prototype map. This is used in fast-path
2158      // checks. Do not alter the prototype after this point.
2159      native_context()->set_regexp_prototype_map(*prototype_map);
2160    }
2161
2162    {
2163      // RegExp getters and setters.
2164
2165      InstallSpeciesGetter(regexp_fun);
2166
2167      // Static properties set by a successful match.
2168
2169      const PropertyAttributes no_enum = DONT_ENUM;
2170      SimpleInstallGetterSetter(regexp_fun, factory->input_string(),
2171                                Builtins::kRegExpInputGetter,
2172                                Builtins::kRegExpInputSetter, no_enum);
2173      SimpleInstallGetterSetter(
2174          regexp_fun, factory->InternalizeUtf8String("$_"),
2175          Builtins::kRegExpInputGetter, Builtins::kRegExpInputSetter, no_enum);
2176
2177      SimpleInstallGetterSetter(
2178          regexp_fun, factory->InternalizeUtf8String("lastMatch"),
2179          Builtins::kRegExpLastMatchGetter, Builtins::kEmptyFunction, no_enum);
2180      SimpleInstallGetterSetter(
2181          regexp_fun, factory->InternalizeUtf8String("$&"),
2182          Builtins::kRegExpLastMatchGetter, Builtins::kEmptyFunction, no_enum);
2183
2184      SimpleInstallGetterSetter(
2185          regexp_fun, factory->InternalizeUtf8String("lastParen"),
2186          Builtins::kRegExpLastParenGetter, Builtins::kEmptyFunction, no_enum);
2187      SimpleInstallGetterSetter(
2188          regexp_fun, factory->InternalizeUtf8String("$+"),
2189          Builtins::kRegExpLastParenGetter, Builtins::kEmptyFunction, no_enum);
2190
2191      SimpleInstallGetterSetter(regexp_fun,
2192                                factory->InternalizeUtf8String("leftContext"),
2193                                Builtins::kRegExpLeftContextGetter,
2194                                Builtins::kEmptyFunction, no_enum);
2195      SimpleInstallGetterSetter(regexp_fun,
2196                                factory->InternalizeUtf8String("$`"),
2197                                Builtins::kRegExpLeftContextGetter,
2198                                Builtins::kEmptyFunction, no_enum);
2199
2200      SimpleInstallGetterSetter(regexp_fun,
2201                                factory->InternalizeUtf8String("rightContext"),
2202                                Builtins::kRegExpRightContextGetter,
2203                                Builtins::kEmptyFunction, no_enum);
2204      SimpleInstallGetterSetter(regexp_fun,
2205                                factory->InternalizeUtf8String("$'"),
2206                                Builtins::kRegExpRightContextGetter,
2207                                Builtins::kEmptyFunction, no_enum);
2208
2209#define INSTALL_CAPTURE_GETTER(i)                         \
2210  SimpleInstallGetterSetter(                              \
2211      regexp_fun, factory->InternalizeUtf8String("$" #i), \
2212      Builtins::kRegExpCapture##i##Getter, Builtins::kEmptyFunction, no_enum)
2213      INSTALL_CAPTURE_GETTER(1);
2214      INSTALL_CAPTURE_GETTER(2);
2215      INSTALL_CAPTURE_GETTER(3);
2216      INSTALL_CAPTURE_GETTER(4);
2217      INSTALL_CAPTURE_GETTER(5);
2218      INSTALL_CAPTURE_GETTER(6);
2219      INSTALL_CAPTURE_GETTER(7);
2220      INSTALL_CAPTURE_GETTER(8);
2221      INSTALL_CAPTURE_GETTER(9);
2222#undef INSTALL_CAPTURE_GETTER
2223    }
2224
2225    DCHECK(regexp_fun->has_initial_map());
2226    Handle<Map> initial_map(regexp_fun->initial_map());
2227
2228    DCHECK_EQ(0, initial_map->GetInObjectProperties());
2229
2230    Map::EnsureDescriptorSlack(initial_map, 1);
2231
2232    // ECMA-262, section 15.10.7.5.
2233    PropertyAttributes writable =
2234        static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE);
2235    Descriptor d = Descriptor::DataField(factory->lastIndex_string(),
2236                                         JSRegExp::kLastIndexFieldIndex,
2237                                         writable, Representation::Tagged());
2238    initial_map->AppendDescriptor(&d);
2239
2240    static const int num_fields = JSRegExp::kInObjectFieldCount;
2241    initial_map->SetInObjectProperties(num_fields);
2242    initial_map->set_unused_property_fields(0);
2243    initial_map->set_instance_size(initial_map->instance_size() +
2244                                   num_fields * kPointerSize);
2245
2246    {  // Internal: RegExpInternalMatch
2247      Handle<JSFunction> function =
2248          factory->NewFunction(isolate->factory()->empty_string(),
2249                               isolate->builtins()->RegExpInternalMatch(),
2250                               JS_OBJECT_TYPE, JSObject::kHeaderSize);
2251      function->shared()->set_internal_formal_parameter_count(2);
2252      function->shared()->set_length(2);
2253      function->shared()->set_native(true);
2254      native_context()->set(Context::REGEXP_INTERNAL_MATCH, *function);
2255    }
2256
2257    // Create the last match info. One for external use, and one for internal
2258    // use when we don't want to modify the externally visible match info.
2259    Handle<RegExpMatchInfo> last_match_info = factory->NewRegExpMatchInfo();
2260    native_context()->set_regexp_last_match_info(*last_match_info);
2261    Handle<RegExpMatchInfo> internal_match_info = factory->NewRegExpMatchInfo();
2262    native_context()->set_regexp_internal_match_info(*internal_match_info);
2263  }
2264
2265  {  // -- E r r o r
2266    InstallError(isolate, global, factory->Error_string(),
2267                 Context::ERROR_FUNCTION_INDEX);
2268    InstallMakeError(isolate, isolate->builtins()->MakeError(),
2269                     Context::MAKE_ERROR_INDEX);
2270  }
2271
2272  {  // -- E v a l E r r o r
2273    InstallError(isolate, global, factory->EvalError_string(),
2274                 Context::EVAL_ERROR_FUNCTION_INDEX);
2275  }
2276
2277  {  // -- R a n g e E r r o r
2278    InstallError(isolate, global, factory->RangeError_string(),
2279                 Context::RANGE_ERROR_FUNCTION_INDEX);
2280    InstallMakeError(isolate, isolate->builtins()->MakeRangeError(),
2281                     Context::MAKE_RANGE_ERROR_INDEX);
2282  }
2283
2284  {  // -- R e f e r e n c e E r r o r
2285    InstallError(isolate, global, factory->ReferenceError_string(),
2286                 Context::REFERENCE_ERROR_FUNCTION_INDEX);
2287  }
2288
2289  {  // -- S y n t a x E r r o r
2290    InstallError(isolate, global, factory->SyntaxError_string(),
2291                 Context::SYNTAX_ERROR_FUNCTION_INDEX);
2292    InstallMakeError(isolate, isolate->builtins()->MakeSyntaxError(),
2293                     Context::MAKE_SYNTAX_ERROR_INDEX);
2294  }
2295
2296  {  // -- T y p e E r r o r
2297    InstallError(isolate, global, factory->TypeError_string(),
2298                 Context::TYPE_ERROR_FUNCTION_INDEX);
2299    InstallMakeError(isolate, isolate->builtins()->MakeTypeError(),
2300                     Context::MAKE_TYPE_ERROR_INDEX);
2301  }
2302
2303  {  // -- U R I E r r o r
2304    InstallError(isolate, global, factory->URIError_string(),
2305                 Context::URI_ERROR_FUNCTION_INDEX);
2306    InstallMakeError(isolate, isolate->builtins()->MakeURIError(),
2307                     Context::MAKE_URI_ERROR_INDEX);
2308  }
2309
2310  {  // -- C o m p i l e E r r o r
2311    Handle<JSObject> dummy = factory->NewJSObject(isolate->object_function());
2312    InstallError(isolate, dummy, factory->CompileError_string(),
2313                 Context::WASM_COMPILE_ERROR_FUNCTION_INDEX);
2314
2315    // -- L i n k E r r o r
2316    InstallError(isolate, dummy, factory->LinkError_string(),
2317                 Context::WASM_LINK_ERROR_FUNCTION_INDEX);
2318
2319    // -- R u n t i m e E r r o r
2320    InstallError(isolate, dummy, factory->RuntimeError_string(),
2321                 Context::WASM_RUNTIME_ERROR_FUNCTION_INDEX);
2322  }
2323
2324  // Initialize the embedder data slot.
2325  Handle<FixedArray> embedder_data = factory->NewFixedArray(3);
2326  native_context()->set_embedder_data(*embedder_data);
2327
2328  {  // -- J S O N
2329    Handle<String> name = factory->InternalizeUtf8String("JSON");
2330    Handle<JSFunction> cons = factory->NewFunction(name);
2331    JSFunction::SetInstancePrototype(cons,
2332        Handle<Object>(native_context()->initial_object_prototype(), isolate));
2333    Handle<JSObject> json_object = factory->NewJSObject(cons, TENURED);
2334    DCHECK(json_object->IsJSObject());
2335    JSObject::AddProperty(global, name, json_object, DONT_ENUM);
2336    SimpleInstallFunction(json_object, "parse", Builtins::kJsonParse, 2, false);
2337    SimpleInstallFunction(json_object, "stringify", Builtins::kJsonStringify, 3,
2338                          true);
2339    JSObject::AddProperty(
2340        json_object, factory->to_string_tag_symbol(),
2341        factory->NewStringFromAsciiChecked("JSON"),
2342        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
2343  }
2344
2345  {  // -- M a t h
2346    Handle<String> name = factory->InternalizeUtf8String("Math");
2347    Handle<JSFunction> cons = factory->NewFunction(name);
2348    JSFunction::SetInstancePrototype(
2349        cons,
2350        Handle<Object>(native_context()->initial_object_prototype(), isolate));
2351    Handle<JSObject> math = factory->NewJSObject(cons, TENURED);
2352    DCHECK(math->IsJSObject());
2353    JSObject::AddProperty(global, name, math, DONT_ENUM);
2354    SimpleInstallFunction(math, "abs", Builtins::kMathAbs, 1, true);
2355    SimpleInstallFunction(math, "acos", Builtins::kMathAcos, 1, true);
2356    SimpleInstallFunction(math, "acosh", Builtins::kMathAcosh, 1, true);
2357    SimpleInstallFunction(math, "asin", Builtins::kMathAsin, 1, true);
2358    SimpleInstallFunction(math, "asinh", Builtins::kMathAsinh, 1, true);
2359    SimpleInstallFunction(math, "atan", Builtins::kMathAtan, 1, true);
2360    SimpleInstallFunction(math, "atanh", Builtins::kMathAtanh, 1, true);
2361    SimpleInstallFunction(math, "atan2", Builtins::kMathAtan2, 2, true);
2362    SimpleInstallFunction(math, "ceil", Builtins::kMathCeil, 1, true);
2363    SimpleInstallFunction(math, "cbrt", Builtins::kMathCbrt, 1, true);
2364    SimpleInstallFunction(math, "expm1", Builtins::kMathExpm1, 1, true);
2365    SimpleInstallFunction(math, "clz32", Builtins::kMathClz32, 1, true);
2366    SimpleInstallFunction(math, "cos", Builtins::kMathCos, 1, true);
2367    SimpleInstallFunction(math, "cosh", Builtins::kMathCosh, 1, true);
2368    SimpleInstallFunction(math, "exp", Builtins::kMathExp, 1, true);
2369    Handle<JSFunction> math_floor =
2370        SimpleInstallFunction(math, "floor", Builtins::kMathFloor, 1, true);
2371    native_context()->set_math_floor(*math_floor);
2372    SimpleInstallFunction(math, "fround", Builtins::kMathFround, 1, true);
2373    SimpleInstallFunction(math, "hypot", Builtins::kMathHypot, 2, false);
2374    SimpleInstallFunction(math, "imul", Builtins::kMathImul, 2, true);
2375    SimpleInstallFunction(math, "log", Builtins::kMathLog, 1, true);
2376    SimpleInstallFunction(math, "log1p", Builtins::kMathLog1p, 1, true);
2377    SimpleInstallFunction(math, "log2", Builtins::kMathLog2, 1, true);
2378    SimpleInstallFunction(math, "log10", Builtins::kMathLog10, 1, true);
2379    SimpleInstallFunction(math, "max", Builtins::kMathMax, 2, false);
2380    SimpleInstallFunction(math, "min", Builtins::kMathMin, 2, false);
2381    Handle<JSFunction> math_pow =
2382        SimpleInstallFunction(math, "pow", Builtins::kMathPow, 2, true);
2383    native_context()->set_math_pow(*math_pow);
2384    SimpleInstallFunction(math, "random", Builtins::kMathRandom, 0, true);
2385    SimpleInstallFunction(math, "round", Builtins::kMathRound, 1, true);
2386    SimpleInstallFunction(math, "sign", Builtins::kMathSign, 1, true);
2387    SimpleInstallFunction(math, "sin", Builtins::kMathSin, 1, true);
2388    SimpleInstallFunction(math, "sinh", Builtins::kMathSinh, 1, true);
2389    SimpleInstallFunction(math, "sqrt", Builtins::kMathSqrt, 1, true);
2390    SimpleInstallFunction(math, "tan", Builtins::kMathTan, 1, true);
2391    SimpleInstallFunction(math, "tanh", Builtins::kMathTanh, 1, true);
2392    SimpleInstallFunction(math, "trunc", Builtins::kMathTrunc, 1, true);
2393
2394    // Install math constants.
2395    double const kE = base::ieee754::exp(1.0);
2396    double const kPI = 3.1415926535897932;
2397    InstallConstant(isolate, math, "E", factory->NewNumber(kE));
2398    InstallConstant(isolate, math, "LN10",
2399                    factory->NewNumber(base::ieee754::log(10.0)));
2400    InstallConstant(isolate, math, "LN2",
2401                    factory->NewNumber(base::ieee754::log(2.0)));
2402    InstallConstant(isolate, math, "LOG10E",
2403                    factory->NewNumber(base::ieee754::log10(kE)));
2404    InstallConstant(isolate, math, "LOG2E",
2405                    factory->NewNumber(base::ieee754::log2(kE)));
2406    InstallConstant(isolate, math, "PI", factory->NewNumber(kPI));
2407    InstallConstant(isolate, math, "SQRT1_2",
2408                    factory->NewNumber(std::sqrt(0.5)));
2409    InstallConstant(isolate, math, "SQRT2", factory->NewNumber(std::sqrt(2.0)));
2410    JSObject::AddProperty(
2411        math, factory->to_string_tag_symbol(),
2412        factory->NewStringFromAsciiChecked("Math"),
2413        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
2414  }
2415
2416#ifdef V8_I18N_SUPPORT
2417  {  // -- I n t l
2418    Handle<String> name = factory->InternalizeUtf8String("Intl");
2419    Handle<JSFunction> cons = factory->NewFunction(name);
2420    JSFunction::SetInstancePrototype(
2421        cons,
2422        Handle<Object>(native_context()->initial_object_prototype(), isolate));
2423    Handle<JSObject> intl = factory->NewJSObject(cons, TENURED);
2424    DCHECK(intl->IsJSObject());
2425    JSObject::AddProperty(global, name, intl, DONT_ENUM);
2426
2427    Handle<JSObject> date_time_format_prototype =
2428        factory->NewJSObject(isolate->object_function(), TENURED);
2429    // Install the @@toStringTag property on the {prototype}.
2430    JSObject::AddProperty(
2431        date_time_format_prototype, factory->to_string_tag_symbol(),
2432        factory->Object_string(),
2433        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
2434    Handle<JSFunction> date_time_format_constructor = InstallFunction(
2435        intl, "DateTimeFormat", JS_OBJECT_TYPE, DateFormat::kSize,
2436        date_time_format_prototype, Builtins::kIllegal);
2437    JSObject::AddProperty(date_time_format_prototype,
2438                          factory->constructor_string(),
2439                          date_time_format_constructor, DONT_ENUM);
2440    InstallWithIntrinsicDefaultProto(
2441        isolate, date_time_format_constructor,
2442        Context::INTL_DATE_TIME_FORMAT_FUNCTION_INDEX);
2443
2444    Handle<JSObject> number_format_prototype =
2445        factory->NewJSObject(isolate->object_function(), TENURED);
2446    // Install the @@toStringTag property on the {prototype}.
2447    JSObject::AddProperty(
2448        number_format_prototype, factory->to_string_tag_symbol(),
2449        factory->Object_string(),
2450        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
2451    Handle<JSFunction> number_format_constructor = InstallFunction(
2452        intl, "NumberFormat", JS_OBJECT_TYPE, NumberFormat::kSize,
2453        number_format_prototype, Builtins::kIllegal);
2454    JSObject::AddProperty(number_format_prototype,
2455                          factory->constructor_string(),
2456                          number_format_constructor, DONT_ENUM);
2457    InstallWithIntrinsicDefaultProto(
2458        isolate, number_format_constructor,
2459        Context::INTL_NUMBER_FORMAT_FUNCTION_INDEX);
2460
2461    Handle<JSObject> collator_prototype =
2462        factory->NewJSObject(isolate->object_function(), TENURED);
2463    // Install the @@toStringTag property on the {prototype}.
2464    JSObject::AddProperty(
2465        collator_prototype, factory->to_string_tag_symbol(),
2466        factory->Object_string(),
2467        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
2468    Handle<JSFunction> collator_constructor =
2469        InstallFunction(intl, "Collator", JS_OBJECT_TYPE, Collator::kSize,
2470                        collator_prototype, Builtins::kIllegal);
2471    JSObject::AddProperty(collator_prototype, factory->constructor_string(),
2472                          collator_constructor, DONT_ENUM);
2473    InstallWithIntrinsicDefaultProto(isolate, collator_constructor,
2474                                     Context::INTL_COLLATOR_FUNCTION_INDEX);
2475
2476    Handle<JSObject> v8_break_iterator_prototype =
2477        factory->NewJSObject(isolate->object_function(), TENURED);
2478    // Install the @@toStringTag property on the {prototype}.
2479    JSObject::AddProperty(
2480        v8_break_iterator_prototype, factory->to_string_tag_symbol(),
2481        factory->Object_string(),
2482        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
2483    Handle<JSFunction> v8_break_iterator_constructor = InstallFunction(
2484        intl, "v8BreakIterator", JS_OBJECT_TYPE, V8BreakIterator::kSize,
2485        v8_break_iterator_prototype, Builtins::kIllegal);
2486    JSObject::AddProperty(v8_break_iterator_prototype,
2487                          factory->constructor_string(),
2488                          v8_break_iterator_constructor, DONT_ENUM);
2489    InstallWithIntrinsicDefaultProto(
2490        isolate, v8_break_iterator_constructor,
2491        Context::INTL_V8_BREAK_ITERATOR_FUNCTION_INDEX);
2492  }
2493#endif  // V8_I18N_SUPPORT
2494
2495  {  // -- A r r a y B u f f e r
2496    Handle<JSFunction> array_buffer_fun = InstallArrayBuffer(
2497        global, "ArrayBuffer", Builtins::kArrayBufferPrototypeGetByteLength,
2498        BuiltinFunctionId::kArrayBufferByteLength);
2499    InstallWithIntrinsicDefaultProto(isolate, array_buffer_fun,
2500                                     Context::ARRAY_BUFFER_FUN_INDEX);
2501    InstallSpeciesGetter(array_buffer_fun);
2502  }
2503
2504  {  // -- T y p e d A r r a y
2505    Handle<JSObject> prototype =
2506        factory->NewJSObject(isolate->object_function(), TENURED);
2507    native_context()->set_typed_array_prototype(*prototype);
2508
2509    Handle<JSFunction> typed_array_fun =
2510        CreateFunction(isolate, factory->InternalizeUtf8String("TypedArray"),
2511                       JS_TYPED_ARRAY_TYPE, JSTypedArray::kSize, prototype,
2512                       Builtins::kIllegal);
2513    typed_array_fun->shared()->set_native(false);
2514    InstallSpeciesGetter(typed_array_fun);
2515
2516    // Install the "constructor" property on the {prototype}.
2517    JSObject::AddProperty(prototype, factory->constructor_string(),
2518                          typed_array_fun, DONT_ENUM);
2519    native_context()->set_typed_array_function(*typed_array_fun);
2520
2521    // Install the "buffer", "byteOffset", "byteLength" and "length"
2522    // getters on the {prototype}.
2523    SimpleInstallGetter(prototype, factory->buffer_string(),
2524                        Builtins::kTypedArrayPrototypeBuffer, false);
2525    SimpleInstallGetter(prototype, factory->byte_length_string(),
2526                        Builtins::kTypedArrayPrototypeByteLength, true,
2527                        kTypedArrayByteLength);
2528    SimpleInstallGetter(prototype, factory->byte_offset_string(),
2529                        Builtins::kTypedArrayPrototypeByteOffset, true,
2530                        kTypedArrayByteOffset);
2531    SimpleInstallGetter(prototype, factory->length_string(),
2532                        Builtins::kTypedArrayPrototypeLength, true,
2533                        kTypedArrayLength);
2534
2535    // Install "keys", "values" and "entries" methods on the {prototype}.
2536    Handle<JSFunction> entries =
2537        SimpleInstallFunction(prototype, factory->entries_string(),
2538                              Builtins::kTypedArrayPrototypeEntries, 0, true);
2539    entries->shared()->set_builtin_function_id(kTypedArrayEntries);
2540
2541    Handle<JSFunction> keys =
2542        SimpleInstallFunction(prototype, factory->keys_string(),
2543                              Builtins::kTypedArrayPrototypeKeys, 0, true);
2544    keys->shared()->set_builtin_function_id(kTypedArrayKeys);
2545
2546    Handle<JSFunction> values =
2547        SimpleInstallFunction(prototype, factory->values_string(),
2548                              Builtins::kTypedArrayPrototypeValues, 0, true);
2549    values->shared()->set_builtin_function_id(kTypedArrayValues);
2550    JSObject::AddProperty(prototype, factory->iterator_symbol(), values,
2551                          DONT_ENUM);
2552
2553    // TODO(caitp): alphasort accessors/methods
2554    SimpleInstallFunction(prototype, "copyWithin",
2555                          Builtins::kTypedArrayPrototypeCopyWithin, 2, false);
2556  }
2557
2558  {  // -- T y p e d A r r a y s
2559#define INSTALL_TYPED_ARRAY(Type, type, TYPE, ctype, size)             \
2560  {                                                                    \
2561    Handle<JSFunction> fun;                                            \
2562    InstallTypedArray(#Type "Array", TYPE##_ELEMENTS, &fun);           \
2563    InstallWithIntrinsicDefaultProto(isolate, fun,                     \
2564                                     Context::TYPE##_ARRAY_FUN_INDEX); \
2565  }
2566    TYPED_ARRAYS(INSTALL_TYPED_ARRAY)
2567#undef INSTALL_TYPED_ARRAY
2568  }
2569
2570  {  // -- D a t a V i e w
2571    Handle<JSObject> prototype =
2572        factory->NewJSObject(isolate->object_function(), TENURED);
2573    Handle<JSFunction> data_view_fun =
2574        InstallFunction(global, "DataView", JS_DATA_VIEW_TYPE,
2575                        JSDataView::kSizeWithInternalFields, prototype,
2576                        Builtins::kDataViewConstructor);
2577    InstallWithIntrinsicDefaultProto(isolate, data_view_fun,
2578                                     Context::DATA_VIEW_FUN_INDEX);
2579    data_view_fun->shared()->SetConstructStub(
2580        *isolate->builtins()->DataViewConstructor_ConstructStub());
2581    data_view_fun->shared()->set_length(3);
2582    data_view_fun->shared()->DontAdaptArguments();
2583
2584    // Install the @@toStringTag property on the {prototype}.
2585    JSObject::AddProperty(
2586        prototype, factory->to_string_tag_symbol(),
2587        factory->NewStringFromAsciiChecked("DataView"),
2588        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
2589
2590    // Install the "constructor" property on the {prototype}.
2591    JSObject::AddProperty(prototype, factory->constructor_string(),
2592                          data_view_fun, DONT_ENUM);
2593
2594    // Install the "buffer", "byteOffset" and "byteLength" getters
2595    // on the {prototype}.
2596    SimpleInstallGetter(prototype, factory->buffer_string(),
2597                        Builtins::kDataViewPrototypeGetBuffer, false,
2598                        kDataViewBuffer);
2599    SimpleInstallGetter(prototype, factory->byte_length_string(),
2600                        Builtins::kDataViewPrototypeGetByteLength, false,
2601                        kDataViewByteLength);
2602    SimpleInstallGetter(prototype, factory->byte_offset_string(),
2603                        Builtins::kDataViewPrototypeGetByteOffset, false,
2604                        kDataViewByteOffset);
2605
2606    SimpleInstallFunction(prototype, "getInt8",
2607                          Builtins::kDataViewPrototypeGetInt8, 1, false);
2608    SimpleInstallFunction(prototype, "setInt8",
2609                          Builtins::kDataViewPrototypeSetInt8, 2, false);
2610    SimpleInstallFunction(prototype, "getUint8",
2611                          Builtins::kDataViewPrototypeGetUint8, 1, false);
2612    SimpleInstallFunction(prototype, "setUint8",
2613                          Builtins::kDataViewPrototypeSetUint8, 2, false);
2614    SimpleInstallFunction(prototype, "getInt16",
2615                          Builtins::kDataViewPrototypeGetInt16, 1, false);
2616    SimpleInstallFunction(prototype, "setInt16",
2617                          Builtins::kDataViewPrototypeSetInt16, 2, false);
2618    SimpleInstallFunction(prototype, "getUint16",
2619                          Builtins::kDataViewPrototypeGetUint16, 1, false);
2620    SimpleInstallFunction(prototype, "setUint16",
2621                          Builtins::kDataViewPrototypeSetUint16, 2, false);
2622    SimpleInstallFunction(prototype, "getInt32",
2623                          Builtins::kDataViewPrototypeGetInt32, 1, false);
2624    SimpleInstallFunction(prototype, "setInt32",
2625                          Builtins::kDataViewPrototypeSetInt32, 2, false);
2626    SimpleInstallFunction(prototype, "getUint32",
2627                          Builtins::kDataViewPrototypeGetUint32, 1, false);
2628    SimpleInstallFunction(prototype, "setUint32",
2629                          Builtins::kDataViewPrototypeSetUint32, 2, false);
2630    SimpleInstallFunction(prototype, "getFloat32",
2631                          Builtins::kDataViewPrototypeGetFloat32, 1, false);
2632    SimpleInstallFunction(prototype, "setFloat32",
2633                          Builtins::kDataViewPrototypeSetFloat32, 2, false);
2634    SimpleInstallFunction(prototype, "getFloat64",
2635                          Builtins::kDataViewPrototypeGetFloat64, 1, false);
2636    SimpleInstallFunction(prototype, "setFloat64",
2637                          Builtins::kDataViewPrototypeSetFloat64, 2, false);
2638  }
2639
2640  {  // -- M a p
2641    Handle<JSFunction> js_map_fun = InstallFunction(
2642        global, "Map", JS_MAP_TYPE, JSMap::kSize,
2643        isolate->initial_object_prototype(), Builtins::kIllegal);
2644    InstallWithIntrinsicDefaultProto(isolate, js_map_fun,
2645                                     Context::JS_MAP_FUN_INDEX);
2646    InstallSpeciesGetter(js_map_fun);
2647  }
2648
2649  {  // -- S e t
2650    Handle<JSFunction> js_set_fun = InstallFunction(
2651        global, "Set", JS_SET_TYPE, JSSet::kSize,
2652        isolate->initial_object_prototype(), Builtins::kIllegal);
2653    InstallWithIntrinsicDefaultProto(isolate, js_set_fun,
2654                                     Context::JS_SET_FUN_INDEX);
2655    InstallSpeciesGetter(js_set_fun);
2656  }
2657
2658  {  // -- J S M o d u l e N a m e s p a c e
2659    Handle<Map> map =
2660        factory->NewMap(JS_MODULE_NAMESPACE_TYPE, JSModuleNamespace::kSize);
2661    Map::SetPrototype(map, isolate->factory()->null_value());
2662    Map::EnsureDescriptorSlack(map, 1);
2663    native_context()->set_js_module_namespace_map(*map);
2664
2665    {  // Install @@toStringTag.
2666      PropertyAttributes attribs =
2667          static_cast<PropertyAttributes>(DONT_DELETE | DONT_ENUM | READ_ONLY);
2668      Descriptor d =
2669          Descriptor::DataField(factory->to_string_tag_symbol(),
2670                                JSModuleNamespace::kToStringTagFieldIndex,
2671                                attribs, Representation::Tagged());
2672      map->AppendDescriptor(&d);
2673    }
2674
2675    map->SetInObjectProperties(JSModuleNamespace::kInObjectFieldCount);
2676  }
2677
2678  {  // -- I t e r a t o r R e s u l t
2679    Handle<Map> map =
2680        factory->NewMap(JS_OBJECT_TYPE, JSIteratorResult::kSize);
2681    Map::SetPrototype(map, isolate->initial_object_prototype());
2682    Map::EnsureDescriptorSlack(map, 2);
2683
2684    {  // value
2685      Descriptor d = Descriptor::DataField(factory->value_string(),
2686                                           JSIteratorResult::kValueIndex, NONE,
2687                                           Representation::Tagged());
2688      map->AppendDescriptor(&d);
2689    }
2690
2691    {  // done
2692      Descriptor d = Descriptor::DataField(factory->done_string(),
2693                                           JSIteratorResult::kDoneIndex, NONE,
2694                                           Representation::Tagged());
2695      map->AppendDescriptor(&d);
2696    }
2697
2698    map->SetConstructor(native_context()->object_function());
2699    map->SetInObjectProperties(2);
2700    native_context()->set_iterator_result_map(*map);
2701  }
2702
2703  {  // -- W e a k M a p
2704    Handle<JSFunction> js_weak_map_fun = InstallFunction(
2705        global, "WeakMap", JS_WEAK_MAP_TYPE, JSWeakMap::kSize,
2706        isolate->initial_object_prototype(), Builtins::kIllegal);
2707    InstallWithIntrinsicDefaultProto(isolate, js_weak_map_fun,
2708                                     Context::JS_WEAK_MAP_FUN_INDEX);
2709  }
2710
2711  {  // -- W e a k S e t
2712    Handle<JSFunction> js_weak_set_fun = InstallFunction(
2713        global, "WeakSet", JS_WEAK_SET_TYPE, JSWeakSet::kSize,
2714        isolate->initial_object_prototype(), Builtins::kIllegal);
2715    InstallWithIntrinsicDefaultProto(isolate, js_weak_set_fun,
2716                                     Context::JS_WEAK_SET_FUN_INDEX);
2717  }
2718
2719  {  // -- P r o x y
2720    CreateJSProxyMaps();
2721
2722    Handle<String> name = factory->Proxy_string();
2723    Handle<Code> code(isolate->builtins()->ProxyConstructor());
2724
2725    Handle<JSFunction> proxy_function =
2726        factory->NewFunction(isolate->proxy_function_map(),
2727                             factory->Proxy_string(), MaybeHandle<Code>(code));
2728
2729    JSFunction::SetInitialMap(
2730        proxy_function, Handle<Map>(native_context()->proxy_map(), isolate),
2731        factory->null_value());
2732
2733    proxy_function->shared()->SetConstructStub(
2734        *isolate->builtins()->ProxyConstructor_ConstructStub());
2735    proxy_function->shared()->set_internal_formal_parameter_count(2);
2736    proxy_function->shared()->set_length(2);
2737
2738    native_context()->set_proxy_function(*proxy_function);
2739    InstallFunction(global, name, proxy_function, factory->Object_string());
2740  }
2741
2742  {  // -- R e f l e c t
2743    Handle<String> reflect_string = factory->InternalizeUtf8String("Reflect");
2744    Handle<JSObject> reflect =
2745        factory->NewJSObject(isolate->object_function(), TENURED);
2746    JSObject::AddProperty(global, reflect_string, reflect, DONT_ENUM);
2747
2748    Handle<JSFunction> define_property =
2749        SimpleInstallFunction(reflect, factory->defineProperty_string(),
2750                              Builtins::kReflectDefineProperty, 3, true);
2751    native_context()->set_reflect_define_property(*define_property);
2752
2753    Handle<JSFunction> delete_property =
2754        SimpleInstallFunction(reflect, factory->deleteProperty_string(),
2755                              Builtins::kReflectDeleteProperty, 2, true);
2756    native_context()->set_reflect_delete_property(*delete_property);
2757
2758    Handle<JSFunction> apply = SimpleInstallFunction(
2759        reflect, factory->apply_string(), Builtins::kReflectApply, 3, false);
2760    native_context()->set_reflect_apply(*apply);
2761
2762    Handle<JSFunction> construct =
2763        SimpleInstallFunction(reflect, factory->construct_string(),
2764                              Builtins::kReflectConstruct, 2, false);
2765    native_context()->set_reflect_construct(*construct);
2766
2767    SimpleInstallFunction(reflect, factory->get_string(), Builtins::kReflectGet,
2768                          2, false);
2769    SimpleInstallFunction(reflect, factory->getOwnPropertyDescriptor_string(),
2770                          Builtins::kReflectGetOwnPropertyDescriptor, 2, true);
2771    SimpleInstallFunction(reflect, factory->getPrototypeOf_string(),
2772                          Builtins::kReflectGetPrototypeOf, 1, true);
2773    SimpleInstallFunction(reflect, factory->has_string(), Builtins::kReflectHas,
2774                          2, true);
2775    SimpleInstallFunction(reflect, factory->isExtensible_string(),
2776                          Builtins::kReflectIsExtensible, 1, true);
2777    SimpleInstallFunction(reflect, factory->ownKeys_string(),
2778                          Builtins::kReflectOwnKeys, 1, true);
2779    SimpleInstallFunction(reflect, factory->preventExtensions_string(),
2780                          Builtins::kReflectPreventExtensions, 1, true);
2781    SimpleInstallFunction(reflect, factory->set_string(), Builtins::kReflectSet,
2782                          3, false);
2783    SimpleInstallFunction(reflect, factory->setPrototypeOf_string(),
2784                          Builtins::kReflectSetPrototypeOf, 2, true);
2785  }
2786
2787  {  // --- B o u n d F u n c t i o n
2788    Handle<Map> map =
2789        factory->NewMap(JS_BOUND_FUNCTION_TYPE, JSBoundFunction::kSize);
2790    map->set_is_callable();
2791    Map::SetPrototype(map, empty_function);
2792
2793    PropertyAttributes roc_attribs =
2794        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY);
2795    Map::EnsureDescriptorSlack(map, 2);
2796
2797    Handle<AccessorInfo> bound_length =
2798        Accessors::BoundFunctionLengthInfo(isolate, roc_attribs);
2799    {  // length
2800      Descriptor d = Descriptor::AccessorConstant(factory->length_string(),
2801                                                  bound_length, roc_attribs);
2802      map->AppendDescriptor(&d);
2803    }
2804    Handle<AccessorInfo> bound_name =
2805        Accessors::BoundFunctionNameInfo(isolate, roc_attribs);
2806    {  // name
2807      Descriptor d = Descriptor::AccessorConstant(factory->name_string(),
2808                                                  bound_name, roc_attribs);
2809      map->AppendDescriptor(&d);
2810    }
2811    map->SetInObjectProperties(0);
2812    native_context()->set_bound_function_without_constructor_map(*map);
2813
2814    map = Map::Copy(map, "IsConstructor");
2815    map->set_is_constructor(true);
2816    native_context()->set_bound_function_with_constructor_map(*map);
2817  }
2818
2819  {  // --- sloppy arguments map
2820    // Make sure we can recognize argument objects at runtime.
2821    // This is done by introducing an anonymous function with
2822    // class_name equals 'Arguments'.
2823    Handle<String> arguments_string = factory->Arguments_string();
2824    Handle<Code> code = isolate->builtins()->Illegal();
2825    Handle<JSFunction> function = factory->NewFunctionWithoutPrototype(
2826        arguments_string, code);
2827    function->shared()->set_instance_class_name(*arguments_string);
2828
2829    Handle<Map> map = factory->NewMap(
2830        JS_ARGUMENTS_TYPE, JSSloppyArgumentsObject::kSize, FAST_ELEMENTS);
2831    // Create the descriptor array for the arguments object.
2832    Map::EnsureDescriptorSlack(map, 2);
2833
2834    {  // length
2835      Descriptor d = Descriptor::DataField(
2836          factory->length_string(), JSSloppyArgumentsObject::kLengthIndex,
2837          DONT_ENUM, Representation::Tagged());
2838      map->AppendDescriptor(&d);
2839    }
2840    {  // callee
2841      Descriptor d = Descriptor::DataField(
2842          factory->callee_string(), JSSloppyArgumentsObject::kCalleeIndex,
2843          DONT_ENUM, Representation::Tagged());
2844      map->AppendDescriptor(&d);
2845    }
2846    // @@iterator method is added later.
2847
2848    map->SetInObjectProperties(2);
2849    native_context()->set_sloppy_arguments_map(*map);
2850
2851    DCHECK(!function->has_initial_map());
2852    JSFunction::SetInitialMap(function, map,
2853                              isolate->initial_object_prototype());
2854
2855    DCHECK(!map->is_dictionary_map());
2856    DCHECK(IsFastObjectElementsKind(map->elements_kind()));
2857  }
2858
2859  {  // --- fast and slow aliased arguments map
2860    Handle<Map> map = isolate->sloppy_arguments_map();
2861    map = Map::Copy(map, "FastAliasedArguments");
2862    map->set_elements_kind(FAST_SLOPPY_ARGUMENTS_ELEMENTS);
2863    DCHECK_EQ(2, map->GetInObjectProperties());
2864    native_context()->set_fast_aliased_arguments_map(*map);
2865
2866    map = Map::Copy(map, "SlowAliasedArguments");
2867    map->set_elements_kind(SLOW_SLOPPY_ARGUMENTS_ELEMENTS);
2868    DCHECK_EQ(2, map->GetInObjectProperties());
2869    native_context()->set_slow_aliased_arguments_map(*map);
2870  }
2871
2872  {  // --- strict mode arguments map
2873    const PropertyAttributes attributes =
2874      static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
2875
2876    // Create the ThrowTypeError function.
2877    Handle<AccessorPair> callee = factory->NewAccessorPair();
2878
2879    Handle<JSFunction> poison = GetStrictArgumentsPoisonFunction();
2880
2881    // Install the ThrowTypeError function.
2882    callee->set_getter(*poison);
2883    callee->set_setter(*poison);
2884
2885    // Create the map. Allocate one in-object field for length.
2886    Handle<Map> map = factory->NewMap(
2887        JS_ARGUMENTS_TYPE, JSStrictArgumentsObject::kSize, FAST_ELEMENTS);
2888    // Create the descriptor array for the arguments object.
2889    Map::EnsureDescriptorSlack(map, 2);
2890
2891    {  // length
2892      Descriptor d = Descriptor::DataField(
2893          factory->length_string(), JSStrictArgumentsObject::kLengthIndex,
2894          DONT_ENUM, Representation::Tagged());
2895      map->AppendDescriptor(&d);
2896    }
2897    {  // callee
2898      Descriptor d = Descriptor::AccessorConstant(factory->callee_string(),
2899                                                  callee, attributes);
2900      map->AppendDescriptor(&d);
2901    }
2902    // @@iterator method is added later.
2903
2904    DCHECK_EQ(native_context()->object_function()->prototype(),
2905              *isolate->initial_object_prototype());
2906    Map::SetPrototype(map, isolate->initial_object_prototype());
2907    map->SetInObjectProperties(1);
2908
2909    // Copy constructor from the sloppy arguments boilerplate.
2910    map->SetConstructor(
2911        native_context()->sloppy_arguments_map()->GetConstructor());
2912
2913    native_context()->set_strict_arguments_map(*map);
2914
2915    DCHECK(!map->is_dictionary_map());
2916    DCHECK(IsFastObjectElementsKind(map->elements_kind()));
2917  }
2918
2919  {  // --- context extension
2920    // Create a function for the context extension objects.
2921    Handle<Code> code = isolate->builtins()->Illegal();
2922    Handle<JSFunction> context_extension_fun = factory->NewFunction(
2923        factory->empty_string(), code, JS_CONTEXT_EXTENSION_OBJECT_TYPE,
2924        JSObject::kHeaderSize);
2925
2926    Handle<String> name = factory->InternalizeOneByteString(
2927        STATIC_CHAR_VECTOR("context_extension"));
2928    context_extension_fun->shared()->set_instance_class_name(*name);
2929    native_context()->set_context_extension_function(*context_extension_fun);
2930  }
2931
2932
2933  {
2934    // Set up the call-as-function delegate.
2935    Handle<Code> code = isolate->builtins()->HandleApiCallAsFunction();
2936    Handle<JSFunction> delegate = factory->NewFunction(
2937        factory->empty_string(), code, JS_OBJECT_TYPE, JSObject::kHeaderSize);
2938    native_context()->set_call_as_function_delegate(*delegate);
2939    delegate->shared()->DontAdaptArguments();
2940  }
2941
2942  {
2943    // Set up the call-as-constructor delegate.
2944    Handle<Code> code = isolate->builtins()->HandleApiCallAsConstructor();
2945    Handle<JSFunction> delegate = factory->NewFunction(
2946        factory->empty_string(), code, JS_OBJECT_TYPE, JSObject::kHeaderSize);
2947    native_context()->set_call_as_constructor_delegate(*delegate);
2948    delegate->shared()->DontAdaptArguments();
2949  }
2950}  // NOLINT(readability/fn_size)
2951
2952void Genesis::InstallTypedArray(const char* name, ElementsKind elements_kind,
2953                                Handle<JSFunction>* fun) {
2954  Handle<JSObject> global = Handle<JSObject>(native_context()->global_object());
2955
2956  Handle<JSObject> typed_array_prototype =
2957      Handle<JSObject>(isolate()->typed_array_prototype());
2958  Handle<JSFunction> typed_array_function =
2959      Handle<JSFunction>(isolate()->typed_array_function());
2960
2961  Handle<JSObject> prototype =
2962      factory()->NewJSObject(isolate()->object_function(), TENURED);
2963  Handle<JSFunction> result = InstallFunction(
2964      global, name, JS_TYPED_ARRAY_TYPE, JSTypedArray::kSizeWithInternalFields,
2965      prototype, Builtins::kIllegal);
2966  result->initial_map()->set_elements_kind(elements_kind);
2967
2968  CHECK(JSObject::SetPrototype(result, typed_array_function, false,
2969                               Object::DONT_THROW)
2970            .FromJust());
2971
2972  CHECK(JSObject::SetPrototype(prototype, typed_array_prototype, false,
2973                               Object::DONT_THROW)
2974            .FromJust());
2975  *fun = result;
2976}
2977
2978
2979void Genesis::InitializeExperimentalGlobal() {
2980#define FEATURE_INITIALIZE_GLOBAL(id, descr) InitializeGlobal_##id();
2981
2982  HARMONY_INPROGRESS(FEATURE_INITIALIZE_GLOBAL)
2983  HARMONY_STAGED(FEATURE_INITIALIZE_GLOBAL)
2984  HARMONY_SHIPPING(FEATURE_INITIALIZE_GLOBAL)
2985#undef FEATURE_INITIALIZE_GLOBAL
2986
2987  InitializeGlobal_enable_fast_array_builtins();
2988}
2989
2990
2991bool Bootstrapper::CompileBuiltin(Isolate* isolate, int index) {
2992  Vector<const char> name = Natives::GetScriptName(index);
2993  Handle<String> source_code =
2994      isolate->bootstrapper()->SourceLookup<Natives>(index);
2995
2996  // We pass in extras_utils so that builtin code can set it up for later use
2997  // by actual extras code, compiled with CompileExtraBuiltin.
2998  Handle<Object> global = isolate->global_object();
2999  Handle<Object> utils = isolate->natives_utils_object();
3000  Handle<Object> extras_utils = isolate->extras_utils_object();
3001  Handle<Object> args[] = {global, utils, extras_utils};
3002
3003  return Bootstrapper::CompileNative(isolate, name, source_code,
3004                                     arraysize(args), args, NATIVES_CODE);
3005}
3006
3007
3008bool Bootstrapper::CompileExperimentalBuiltin(Isolate* isolate, int index) {
3009  HandleScope scope(isolate);
3010  Vector<const char> name = ExperimentalNatives::GetScriptName(index);
3011  Handle<String> source_code =
3012      isolate->bootstrapper()->SourceLookup<ExperimentalNatives>(index);
3013  Handle<Object> global = isolate->global_object();
3014  Handle<Object> utils = isolate->natives_utils_object();
3015  Handle<Object> args[] = {global, utils};
3016  return Bootstrapper::CompileNative(isolate, name, source_code,
3017                                     arraysize(args), args, NATIVES_CODE);
3018}
3019
3020
3021bool Bootstrapper::CompileExtraBuiltin(Isolate* isolate, int index) {
3022  HandleScope scope(isolate);
3023  Vector<const char> name = ExtraNatives::GetScriptName(index);
3024  Handle<String> source_code =
3025      isolate->bootstrapper()->SourceLookup<ExtraNatives>(index);
3026  Handle<Object> global = isolate->global_object();
3027  Handle<Object> binding = isolate->extras_binding_object();
3028  Handle<Object> extras_utils = isolate->extras_utils_object();
3029  Handle<Object> args[] = {global, binding, extras_utils};
3030  return Bootstrapper::CompileNative(isolate, name, source_code,
3031                                     arraysize(args), args, EXTENSION_CODE);
3032}
3033
3034
3035bool Bootstrapper::CompileExperimentalExtraBuiltin(Isolate* isolate,
3036                                                   int index) {
3037  HandleScope scope(isolate);
3038  Vector<const char> name = ExperimentalExtraNatives::GetScriptName(index);
3039  Handle<String> source_code =
3040      isolate->bootstrapper()->SourceLookup<ExperimentalExtraNatives>(index);
3041  Handle<Object> global = isolate->global_object();
3042  Handle<Object> binding = isolate->extras_binding_object();
3043  Handle<Object> extras_utils = isolate->extras_utils_object();
3044  Handle<Object> args[] = {global, binding, extras_utils};
3045  return Bootstrapper::CompileNative(isolate, name, source_code,
3046                                     arraysize(args), args, EXTENSION_CODE);
3047}
3048
3049bool Bootstrapper::CompileNative(Isolate* isolate, Vector<const char> name,
3050                                 Handle<String> source, int argc,
3051                                 Handle<Object> argv[],
3052                                 NativesFlag natives_flag) {
3053  SuppressDebug compiling_natives(isolate->debug());
3054  // During genesis, the boilerplate for stack overflow won't work until the
3055  // environment has been at least partially initialized. Add a stack check
3056  // before entering JS code to catch overflow early.
3057  StackLimitCheck check(isolate);
3058  if (check.JsHasOverflowed(4 * KB)) {
3059    isolate->StackOverflow();
3060    return false;
3061  }
3062
3063  Handle<Context> context(isolate->context());
3064
3065  Handle<String> script_name =
3066      isolate->factory()->NewStringFromUtf8(name).ToHandleChecked();
3067  Handle<SharedFunctionInfo> function_info =
3068      Compiler::GetSharedFunctionInfoForScript(
3069          source, script_name, 0, 0, ScriptOriginOptions(), Handle<Object>(),
3070          context, NULL, NULL, ScriptCompiler::kNoCompileOptions, natives_flag);
3071  if (function_info.is_null()) return false;
3072
3073  DCHECK(context->IsNativeContext());
3074
3075  Handle<JSFunction> fun =
3076      isolate->factory()->NewFunctionFromSharedFunctionInfo(function_info,
3077                                                            context);
3078  Handle<Object> receiver = isolate->factory()->undefined_value();
3079
3080  // For non-extension scripts, run script to get the function wrapper.
3081  Handle<Object> wrapper;
3082  if (!Execution::TryCall(isolate, fun, receiver, 0, nullptr,
3083                          Execution::MessageHandling::kKeepPending, nullptr)
3084           .ToHandle(&wrapper)) {
3085    return false;
3086  }
3087  // Then run the function wrapper.
3088  return !Execution::TryCall(isolate, Handle<JSFunction>::cast(wrapper),
3089                             receiver, argc, argv,
3090                             Execution::MessageHandling::kKeepPending, nullptr)
3091              .is_null();
3092}
3093
3094
3095bool Genesis::CallUtilsFunction(Isolate* isolate, const char* name) {
3096  Handle<JSObject> utils =
3097      Handle<JSObject>::cast(isolate->natives_utils_object());
3098  Handle<String> name_string =
3099      isolate->factory()->NewStringFromAsciiChecked(name);
3100  Handle<Object> fun = JSObject::GetDataProperty(utils, name_string);
3101  Handle<Object> receiver = isolate->factory()->undefined_value();
3102  Handle<Object> args[] = {utils};
3103  return !Execution::TryCall(isolate, fun, receiver, 1, args,
3104                             Execution::MessageHandling::kKeepPending, nullptr)
3105              .is_null();
3106}
3107
3108
3109bool Genesis::CompileExtension(Isolate* isolate, v8::Extension* extension) {
3110  Factory* factory = isolate->factory();
3111  HandleScope scope(isolate);
3112  Handle<SharedFunctionInfo> function_info;
3113
3114  Handle<String> source =
3115      isolate->factory()
3116          ->NewExternalStringFromOneByte(extension->source())
3117          .ToHandleChecked();
3118  DCHECK(source->IsOneByteRepresentation());
3119
3120  // If we can't find the function in the cache, we compile a new
3121  // function and insert it into the cache.
3122  Vector<const char> name = CStrVector(extension->name());
3123  SourceCodeCache* cache = isolate->bootstrapper()->extensions_cache();
3124  Handle<Context> context(isolate->context());
3125  DCHECK(context->IsNativeContext());
3126
3127  if (!cache->Lookup(name, &function_info)) {
3128    Handle<String> script_name =
3129        factory->NewStringFromUtf8(name).ToHandleChecked();
3130    function_info = Compiler::GetSharedFunctionInfoForScript(
3131        source, script_name, 0, 0, ScriptOriginOptions(), Handle<Object>(),
3132        context, extension, NULL, ScriptCompiler::kNoCompileOptions,
3133        EXTENSION_CODE);
3134    if (function_info.is_null()) return false;
3135    cache->Add(name, function_info);
3136  }
3137
3138  // Set up the function context. Conceptually, we should clone the
3139  // function before overwriting the context but since we're in a
3140  // single-threaded environment it is not strictly necessary.
3141  Handle<JSFunction> fun =
3142      factory->NewFunctionFromSharedFunctionInfo(function_info, context);
3143
3144  // Call function using either the runtime object or the global
3145  // object as the receiver. Provide no parameters.
3146  Handle<Object> receiver = isolate->global_object();
3147  return !Execution::TryCall(isolate, fun, receiver, 0, nullptr,
3148                             Execution::MessageHandling::kKeepPending, nullptr)
3149              .is_null();
3150}
3151
3152
3153static Handle<JSObject> ResolveBuiltinIdHolder(Handle<Context> native_context,
3154                                               const char* holder_expr) {
3155  Isolate* isolate = native_context->GetIsolate();
3156  Factory* factory = isolate->factory();
3157  Handle<JSGlobalObject> global(native_context->global_object());
3158  const char* period_pos = strchr(holder_expr, '.');
3159  if (period_pos == NULL) {
3160    return Handle<JSObject>::cast(
3161        Object::GetPropertyOrElement(
3162            global, factory->InternalizeUtf8String(holder_expr))
3163            .ToHandleChecked());
3164  }
3165  const char* inner = period_pos + 1;
3166  DCHECK(!strchr(inner, '.'));
3167  Vector<const char> property(holder_expr,
3168                              static_cast<int>(period_pos - holder_expr));
3169  Handle<String> property_string = factory->InternalizeUtf8String(property);
3170  DCHECK(!property_string.is_null());
3171  Handle<JSObject> object = Handle<JSObject>::cast(
3172      JSReceiver::GetProperty(global, property_string).ToHandleChecked());
3173  if (strcmp("prototype", inner) == 0) {
3174    Handle<JSFunction> function = Handle<JSFunction>::cast(object);
3175    return Handle<JSObject>(JSObject::cast(function->prototype()));
3176  }
3177  Handle<String> inner_string = factory->InternalizeUtf8String(inner);
3178  DCHECK(!inner_string.is_null());
3179  Handle<Object> value =
3180      JSReceiver::GetProperty(object, inner_string).ToHandleChecked();
3181  return Handle<JSObject>::cast(value);
3182}
3183
3184void Genesis::ConfigureUtilsObject(GlobalContextType context_type) {
3185  switch (context_type) {
3186    // We still need the utils object to find debug functions.
3187    case DEBUG_CONTEXT:
3188      return;
3189    // Expose the natives in global if a valid name for it is specified.
3190    case FULL_CONTEXT: {
3191      // We still need the utils object after deserialization.
3192      if (isolate()->serializer_enabled()) return;
3193      if (FLAG_expose_natives_as == NULL) break;
3194      if (strlen(FLAG_expose_natives_as) == 0) break;
3195      HandleScope scope(isolate());
3196      Handle<String> natives_key =
3197          factory()->InternalizeUtf8String(FLAG_expose_natives_as);
3198      uint32_t dummy_index;
3199      if (natives_key->AsArrayIndex(&dummy_index)) break;
3200      Handle<Object> utils = isolate()->natives_utils_object();
3201      Handle<JSObject> global = isolate()->global_object();
3202      JSObject::AddProperty(global, natives_key, utils, DONT_ENUM);
3203      break;
3204    }
3205  }
3206
3207  // The utils object can be removed for cases that reach this point.
3208  native_context()->set_natives_utils_object(heap()->undefined_value());
3209  native_context()->set_extras_utils_object(heap()->undefined_value());
3210  native_context()->set_exports_container(heap()->undefined_value());
3211}
3212
3213
3214void Bootstrapper::ExportFromRuntime(Isolate* isolate,
3215                                     Handle<JSObject> container) {
3216  Factory* factory = isolate->factory();
3217  HandleScope scope(isolate);
3218  Handle<Context> native_context = isolate->native_context();
3219#define EXPORT_PRIVATE_SYMBOL(NAME)                                       \
3220  Handle<String> NAME##_name = factory->NewStringFromAsciiChecked(#NAME); \
3221  JSObject::AddProperty(container, NAME##_name, factory->NAME(), NONE);
3222  PRIVATE_SYMBOL_LIST(EXPORT_PRIVATE_SYMBOL)
3223#undef EXPORT_PRIVATE_SYMBOL
3224
3225#define EXPORT_PUBLIC_SYMBOL(NAME, DESCRIPTION)                           \
3226  Handle<String> NAME##_name = factory->NewStringFromAsciiChecked(#NAME); \
3227  JSObject::AddProperty(container, NAME##_name, factory->NAME(), NONE);
3228  PUBLIC_SYMBOL_LIST(EXPORT_PUBLIC_SYMBOL)
3229  WELL_KNOWN_SYMBOL_LIST(EXPORT_PUBLIC_SYMBOL)
3230#undef EXPORT_PUBLIC_SYMBOL
3231
3232  {
3233    Handle<JSFunction> to_string = InstallFunction(
3234        container, "object_to_string", JS_OBJECT_TYPE, JSObject::kHeaderSize,
3235        MaybeHandle<JSObject>(), Builtins::kObjectProtoToString);
3236    to_string->shared()->set_internal_formal_parameter_count(0);
3237    to_string->shared()->set_length(0);
3238    native_context->set_object_to_string(*to_string);
3239  }
3240
3241  Handle<JSObject> iterator_prototype(
3242      native_context->initial_iterator_prototype());
3243
3244  JSObject::AddProperty(container,
3245                        factory->InternalizeUtf8String("IteratorPrototype"),
3246                        iterator_prototype, NONE);
3247
3248  {
3249    PrototypeIterator iter(native_context->generator_function_map());
3250    Handle<JSObject> generator_function_prototype(iter.GetCurrent<JSObject>());
3251
3252    JSObject::AddProperty(
3253        container, factory->InternalizeUtf8String("GeneratorFunctionPrototype"),
3254        generator_function_prototype, NONE);
3255
3256    static const bool kUseStrictFunctionMap = true;
3257    Handle<JSFunction> generator_function_function = InstallFunction(
3258        container, "GeneratorFunction", JS_FUNCTION_TYPE, JSFunction::kSize,
3259        generator_function_prototype, Builtins::kGeneratorFunctionConstructor,
3260        kUseStrictFunctionMap);
3261    generator_function_function->set_prototype_or_initial_map(
3262        native_context->generator_function_map());
3263    generator_function_function->shared()->DontAdaptArguments();
3264    generator_function_function->shared()->SetConstructStub(
3265        *isolate->builtins()->GeneratorFunctionConstructor());
3266    generator_function_function->shared()->set_length(1);
3267    InstallWithIntrinsicDefaultProto(
3268        isolate, generator_function_function,
3269        Context::GENERATOR_FUNCTION_FUNCTION_INDEX);
3270
3271    JSObject::ForceSetPrototype(generator_function_function,
3272                                isolate->function_function());
3273    JSObject::AddProperty(
3274        generator_function_prototype, factory->constructor_string(),
3275        generator_function_function,
3276        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
3277
3278    native_context->generator_function_map()->SetConstructor(
3279        *generator_function_function);
3280  }
3281
3282  {  // -- S e t I t e r a t o r
3283    Handle<JSObject> set_iterator_prototype =
3284        isolate->factory()->NewJSObject(isolate->object_function(), TENURED);
3285    JSObject::ForceSetPrototype(set_iterator_prototype, iterator_prototype);
3286    Handle<JSFunction> set_iterator_function = InstallFunction(
3287        container, "SetIterator", JS_SET_ITERATOR_TYPE, JSSetIterator::kSize,
3288        set_iterator_prototype, Builtins::kIllegal);
3289    native_context->set_set_iterator_map(set_iterator_function->initial_map());
3290  }
3291
3292  {  // -- M a p I t e r a t o r
3293    Handle<JSObject> map_iterator_prototype =
3294        isolate->factory()->NewJSObject(isolate->object_function(), TENURED);
3295    JSObject::ForceSetPrototype(map_iterator_prototype, iterator_prototype);
3296    Handle<JSFunction> map_iterator_function = InstallFunction(
3297        container, "MapIterator", JS_MAP_ITERATOR_TYPE, JSMapIterator::kSize,
3298        map_iterator_prototype, Builtins::kIllegal);
3299    native_context->set_map_iterator_map(map_iterator_function->initial_map());
3300  }
3301
3302  {  // -- S c r i p t
3303    // Builtin functions for Script.
3304    Handle<JSFunction> script_fun = InstallFunction(
3305        container, "Script", JS_VALUE_TYPE, JSValue::kSize,
3306        isolate->initial_object_prototype(), Builtins::kUnsupportedThrower);
3307    Handle<JSObject> prototype =
3308        factory->NewJSObject(isolate->object_function(), TENURED);
3309    Accessors::FunctionSetPrototype(script_fun, prototype).Assert();
3310    native_context->set_script_function(*script_fun);
3311
3312    Handle<Map> script_map = Handle<Map>(script_fun->initial_map());
3313    Map::EnsureDescriptorSlack(script_map, 15);
3314
3315    PropertyAttributes attribs =
3316        static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
3317
3318    Handle<AccessorInfo> script_column =
3319        Accessors::ScriptColumnOffsetInfo(isolate, attribs);
3320    {
3321      Descriptor d = Descriptor::AccessorConstant(
3322          Handle<Name>(Name::cast(script_column->name())), script_column,
3323          attribs);
3324      script_map->AppendDescriptor(&d);
3325    }
3326
3327    Handle<AccessorInfo> script_id = Accessors::ScriptIdInfo(isolate, attribs);
3328    {
3329      Descriptor d = Descriptor::AccessorConstant(
3330          Handle<Name>(Name::cast(script_id->name())), script_id, attribs);
3331      script_map->AppendDescriptor(&d);
3332    }
3333
3334
3335    Handle<AccessorInfo> script_name =
3336        Accessors::ScriptNameInfo(isolate, attribs);
3337    {
3338      Descriptor d = Descriptor::AccessorConstant(
3339          Handle<Name>(Name::cast(script_name->name())), script_name, attribs);
3340      script_map->AppendDescriptor(&d);
3341    }
3342
3343    Handle<AccessorInfo> script_line =
3344        Accessors::ScriptLineOffsetInfo(isolate, attribs);
3345    {
3346      Descriptor d = Descriptor::AccessorConstant(
3347          Handle<Name>(Name::cast(script_line->name())), script_line, attribs);
3348      script_map->AppendDescriptor(&d);
3349    }
3350
3351    Handle<AccessorInfo> script_source =
3352        Accessors::ScriptSourceInfo(isolate, attribs);
3353    {
3354      Descriptor d = Descriptor::AccessorConstant(
3355          Handle<Name>(Name::cast(script_source->name())), script_source,
3356          attribs);
3357      script_map->AppendDescriptor(&d);
3358    }
3359
3360    Handle<AccessorInfo> script_type =
3361        Accessors::ScriptTypeInfo(isolate, attribs);
3362    {
3363      Descriptor d = Descriptor::AccessorConstant(
3364          Handle<Name>(Name::cast(script_type->name())), script_type, attribs);
3365      script_map->AppendDescriptor(&d);
3366    }
3367
3368    Handle<AccessorInfo> script_compilation_type =
3369        Accessors::ScriptCompilationTypeInfo(isolate, attribs);
3370    {
3371      Descriptor d = Descriptor::AccessorConstant(
3372          Handle<Name>(Name::cast(script_compilation_type->name())),
3373          script_compilation_type, attribs);
3374      script_map->AppendDescriptor(&d);
3375    }
3376
3377    Handle<AccessorInfo> script_context_data =
3378        Accessors::ScriptContextDataInfo(isolate, attribs);
3379    {
3380      Descriptor d = Descriptor::AccessorConstant(
3381          Handle<Name>(Name::cast(script_context_data->name())),
3382          script_context_data, attribs);
3383      script_map->AppendDescriptor(&d);
3384    }
3385
3386    Handle<AccessorInfo> script_eval_from_script =
3387        Accessors::ScriptEvalFromScriptInfo(isolate, attribs);
3388    {
3389      Descriptor d = Descriptor::AccessorConstant(
3390          Handle<Name>(Name::cast(script_eval_from_script->name())),
3391          script_eval_from_script, attribs);
3392      script_map->AppendDescriptor(&d);
3393    }
3394
3395    Handle<AccessorInfo> script_eval_from_script_position =
3396        Accessors::ScriptEvalFromScriptPositionInfo(isolate, attribs);
3397    {
3398      Descriptor d = Descriptor::AccessorConstant(
3399          Handle<Name>(Name::cast(script_eval_from_script_position->name())),
3400          script_eval_from_script_position, attribs);
3401      script_map->AppendDescriptor(&d);
3402    }
3403
3404    Handle<AccessorInfo> script_eval_from_function_name =
3405        Accessors::ScriptEvalFromFunctionNameInfo(isolate, attribs);
3406    {
3407      Descriptor d = Descriptor::AccessorConstant(
3408          Handle<Name>(Name::cast(script_eval_from_function_name->name())),
3409          script_eval_from_function_name, attribs);
3410      script_map->AppendDescriptor(&d);
3411    }
3412
3413    Handle<AccessorInfo> script_source_url =
3414        Accessors::ScriptSourceUrlInfo(isolate, attribs);
3415    {
3416      Descriptor d = Descriptor::AccessorConstant(
3417          Handle<Name>(Name::cast(script_source_url->name())),
3418          script_source_url, attribs);
3419      script_map->AppendDescriptor(&d);
3420    }
3421
3422    Handle<AccessorInfo> script_source_mapping_url =
3423        Accessors::ScriptSourceMappingUrlInfo(isolate, attribs);
3424    {
3425      Descriptor d = Descriptor::AccessorConstant(
3426          Handle<Name>(Name::cast(script_source_mapping_url->name())),
3427          script_source_mapping_url, attribs);
3428      script_map->AppendDescriptor(&d);
3429    }
3430  }
3431
3432  {  // -- A s y n c F u n c t i o n
3433    // Builtin functions for AsyncFunction.
3434    PrototypeIterator iter(native_context->async_function_map());
3435    Handle<JSObject> async_function_prototype(iter.GetCurrent<JSObject>());
3436
3437    static const bool kUseStrictFunctionMap = true;
3438    Handle<JSFunction> async_function_constructor = InstallFunction(
3439        container, "AsyncFunction", JS_FUNCTION_TYPE, JSFunction::kSize,
3440        async_function_prototype, Builtins::kAsyncFunctionConstructor,
3441        kUseStrictFunctionMap);
3442    async_function_constructor->shared()->DontAdaptArguments();
3443    async_function_constructor->shared()->SetConstructStub(
3444        *isolate->builtins()->AsyncFunctionConstructor());
3445    async_function_constructor->shared()->set_length(1);
3446    InstallWithIntrinsicDefaultProto(isolate, async_function_constructor,
3447                                     Context::ASYNC_FUNCTION_FUNCTION_INDEX);
3448    JSObject::ForceSetPrototype(async_function_constructor,
3449                                isolate->function_function());
3450
3451    JSObject::AddProperty(
3452        async_function_prototype, factory->constructor_string(),
3453        async_function_constructor,
3454        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
3455
3456    JSFunction::SetPrototype(async_function_constructor,
3457                             async_function_prototype);
3458
3459    {
3460      Handle<JSFunction> function =
3461          SimpleCreateFunction(isolate, factory->empty_string(),
3462                               Builtins::kAsyncFunctionAwaitCaught, 3, false);
3463      InstallWithIntrinsicDefaultProto(
3464          isolate, function, Context::ASYNC_FUNCTION_AWAIT_CAUGHT_INDEX);
3465    }
3466
3467    {
3468      Handle<JSFunction> function =
3469          SimpleCreateFunction(isolate, factory->empty_string(),
3470                               Builtins::kAsyncFunctionAwaitUncaught, 3, false);
3471      InstallWithIntrinsicDefaultProto(
3472          isolate, function, Context::ASYNC_FUNCTION_AWAIT_UNCAUGHT_INDEX);
3473    }
3474
3475    {
3476      Handle<Code> code =
3477          isolate->builtins()->AsyncFunctionAwaitRejectClosure();
3478      Handle<SharedFunctionInfo> info =
3479          factory->NewSharedFunctionInfo(factory->empty_string(), code, false);
3480      info->set_internal_formal_parameter_count(1);
3481      info->set_length(1);
3482      native_context->set_async_function_await_reject_shared_fun(*info);
3483    }
3484
3485    {
3486      Handle<Code> code =
3487          isolate->builtins()->AsyncFunctionAwaitResolveClosure();
3488      Handle<SharedFunctionInfo> info =
3489          factory->NewSharedFunctionInfo(factory->empty_string(), code, false);
3490      info->set_internal_formal_parameter_count(1);
3491      info->set_length(1);
3492      native_context->set_async_function_await_resolve_shared_fun(*info);
3493    }
3494
3495    {
3496      Handle<JSFunction> function =
3497          SimpleCreateFunction(isolate, factory->empty_string(),
3498                               Builtins::kAsyncFunctionPromiseCreate, 0, false);
3499      InstallWithIntrinsicDefaultProto(
3500          isolate, function, Context::ASYNC_FUNCTION_PROMISE_CREATE_INDEX);
3501    }
3502
3503    {
3504      Handle<JSFunction> function = SimpleCreateFunction(
3505          isolate, factory->empty_string(),
3506          Builtins::kAsyncFunctionPromiseRelease, 1, false);
3507      InstallWithIntrinsicDefaultProto(
3508          isolate, function, Context::ASYNC_FUNCTION_PROMISE_RELEASE_INDEX);
3509    }
3510  }
3511
3512  {  // -- C a l l S i t e
3513    // Builtin functions for CallSite.
3514
3515    // CallSites are a special case; the constructor is for our private use
3516    // only, therefore we set it up as a builtin that throws. Internally, we use
3517    // CallSiteUtils::Construct to create CallSite objects.
3518
3519    Handle<JSFunction> callsite_fun = InstallFunction(
3520        container, "CallSite", JS_OBJECT_TYPE, JSObject::kHeaderSize,
3521        isolate->initial_object_prototype(), Builtins::kUnsupportedThrower);
3522    callsite_fun->shared()->DontAdaptArguments();
3523    isolate->native_context()->set_callsite_function(*callsite_fun);
3524
3525    {
3526      Handle<JSObject> proto =
3527          factory->NewJSObject(isolate->object_function(), TENURED);
3528      JSObject::AddProperty(proto, factory->constructor_string(), callsite_fun,
3529                            DONT_ENUM);
3530
3531      struct FunctionInfo {
3532        const char* name;
3533        Builtins::Name id;
3534      };
3535
3536      FunctionInfo infos[] = {
3537          {"getColumnNumber", Builtins::kCallSitePrototypeGetColumnNumber},
3538          {"getEvalOrigin", Builtins::kCallSitePrototypeGetEvalOrigin},
3539          {"getFileName", Builtins::kCallSitePrototypeGetFileName},
3540          {"getFunction", Builtins::kCallSitePrototypeGetFunction},
3541          {"getFunctionName", Builtins::kCallSitePrototypeGetFunctionName},
3542          {"getLineNumber", Builtins::kCallSitePrototypeGetLineNumber},
3543          {"getMethodName", Builtins::kCallSitePrototypeGetMethodName},
3544          {"getPosition", Builtins::kCallSitePrototypeGetPosition},
3545          {"getScriptNameOrSourceURL",
3546           Builtins::kCallSitePrototypeGetScriptNameOrSourceURL},
3547          {"getThis", Builtins::kCallSitePrototypeGetThis},
3548          {"getTypeName", Builtins::kCallSitePrototypeGetTypeName},
3549          {"isConstructor", Builtins::kCallSitePrototypeIsConstructor},
3550          {"isEval", Builtins::kCallSitePrototypeIsEval},
3551          {"isNative", Builtins::kCallSitePrototypeIsNative},
3552          {"isToplevel", Builtins::kCallSitePrototypeIsToplevel},
3553          {"toString", Builtins::kCallSitePrototypeToString}};
3554
3555      PropertyAttributes attrs =
3556          static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
3557
3558      Handle<JSFunction> fun;
3559      for (const FunctionInfo& info : infos) {
3560        SimpleInstallFunction(proto, info.name, info.id, 0, true, attrs);
3561      }
3562
3563      Accessors::FunctionSetPrototype(callsite_fun, proto).Assert();
3564    }
3565  }
3566  isolate->native_context()->set_exports_container(*container);
3567}
3568
3569
3570#define EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(id) \
3571  void Genesis::InitializeGlobal_##id() {}
3572
3573EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_do_expressions)
3574EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_regexp_lookbehind)
3575EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_regexp_named_captures)
3576EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_regexp_property)
3577EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_function_sent)
3578EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_tailcalls)
3579EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_restrictive_generators)
3580EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_trailing_commas)
3581EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_function_tostring)
3582EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_class_fields)
3583EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_object_rest_spread)
3584EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_dynamic_import)
3585EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_template_escapes)
3586
3587void InstallPublicSymbol(Factory* factory, Handle<Context> native_context,
3588                         const char* name, Handle<Symbol> value) {
3589  Handle<JSGlobalObject> global(
3590      JSGlobalObject::cast(native_context->global_object()));
3591  Handle<String> symbol_string = factory->InternalizeUtf8String("Symbol");
3592  Handle<JSObject> symbol = Handle<JSObject>::cast(
3593      JSObject::GetProperty(global, symbol_string).ToHandleChecked());
3594  Handle<String> name_string = factory->InternalizeUtf8String(name);
3595  PropertyAttributes attributes =
3596      static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
3597  JSObject::AddProperty(symbol, name_string, value, attributes);
3598}
3599
3600void Genesis::InitializeGlobal_enable_fast_array_builtins() {
3601  if (!FLAG_enable_fast_array_builtins) return;
3602
3603  Handle<JSGlobalObject> global(native_context()->global_object());
3604  Isolate* isolate = global->GetIsolate();
3605  Factory* factory = isolate->factory();
3606
3607  LookupIterator it1(global, factory->NewStringFromAsciiChecked("Array"),
3608                     LookupIterator::OWN_SKIP_INTERCEPTOR);
3609  Handle<Object> array_object = Object::GetProperty(&it1).ToHandleChecked();
3610  LookupIterator it2(array_object,
3611                     factory->NewStringFromAsciiChecked("prototype"),
3612                     LookupIterator::OWN_SKIP_INTERCEPTOR);
3613  Handle<Object> array_prototype = Object::GetProperty(&it2).ToHandleChecked();
3614  LookupIterator it3(array_prototype,
3615                     factory->NewStringFromAsciiChecked("forEach"),
3616                     LookupIterator::OWN_SKIP_INTERCEPTOR);
3617  Handle<Object> for_each_function =
3618      Object::GetProperty(&it3).ToHandleChecked();
3619  Handle<JSFunction>::cast(for_each_function)
3620      ->set_code(isolate->builtins()->builtin(Builtins::kArrayForEach));
3621  Handle<JSFunction>::cast(for_each_function)
3622      ->shared()
3623      ->set_code(isolate->builtins()->builtin(Builtins::kArrayForEach));
3624}
3625
3626void Genesis::InitializeGlobal_harmony_sharedarraybuffer() {
3627  if (!FLAG_harmony_sharedarraybuffer) return;
3628
3629  Handle<JSGlobalObject> global(native_context()->global_object());
3630  Isolate* isolate = global->GetIsolate();
3631  Factory* factory = isolate->factory();
3632
3633  Handle<JSFunction> shared_array_buffer_fun =
3634      InstallArrayBuffer(global, "SharedArrayBuffer",
3635                         Builtins::kSharedArrayBufferPrototypeGetByteLength,
3636                         BuiltinFunctionId::kSharedArrayBufferByteLength);
3637  native_context()->set_shared_array_buffer_fun(*shared_array_buffer_fun);
3638
3639  Handle<String> name = factory->InternalizeUtf8String("Atomics");
3640  Handle<JSFunction> cons = factory->NewFunction(name);
3641  JSFunction::SetInstancePrototype(
3642      cons,
3643      Handle<Object>(native_context()->initial_object_prototype(), isolate));
3644  Handle<JSObject> atomics_object = factory->NewJSObject(cons, TENURED);
3645  DCHECK(atomics_object->IsJSObject());
3646  JSObject::AddProperty(global, name, atomics_object, DONT_ENUM);
3647
3648  SimpleInstallFunction(atomics_object, factory->InternalizeUtf8String("load"),
3649                        Builtins::kAtomicsLoad, 2, true);
3650  SimpleInstallFunction(atomics_object, factory->InternalizeUtf8String("store"),
3651                        Builtins::kAtomicsStore, 3, true);
3652}
3653
3654void Genesis::InitializeGlobal_harmony_array_prototype_values() {
3655  if (!FLAG_harmony_array_prototype_values) return;
3656  Handle<JSFunction> array_constructor(native_context()->array_function());
3657  Handle<JSObject> array_prototype(
3658      JSObject::cast(array_constructor->instance_prototype()));
3659  Handle<Object> values_iterator =
3660      JSObject::GetProperty(array_prototype, factory()->iterator_symbol())
3661          .ToHandleChecked();
3662  DCHECK(values_iterator->IsJSFunction());
3663  JSObject::AddProperty(array_prototype, factory()->values_string(),
3664                        values_iterator, DONT_ENUM);
3665
3666  Handle<Object> unscopables =
3667      JSObject::GetProperty(array_prototype, factory()->unscopables_symbol())
3668          .ToHandleChecked();
3669  DCHECK(unscopables->IsJSObject());
3670  JSObject::AddProperty(Handle<JSObject>::cast(unscopables),
3671                        factory()->values_string(), factory()->true_value(),
3672                        NONE);
3673}
3674
3675void Genesis::InitializeGlobal_harmony_async_iteration() {
3676  if (!FLAG_harmony_async_iteration) return;
3677  Handle<JSFunction> symbol_fun(native_context()->symbol_function());
3678  InstallConstant(isolate(), symbol_fun, "asyncIterator",
3679                  factory()->async_iterator_symbol());
3680}
3681
3682void Genesis::InitializeGlobal_harmony_promise_finally() {
3683  if (!FLAG_harmony_promise_finally) return;
3684
3685  Handle<JSFunction> constructor(native_context()->promise_function());
3686  Handle<JSObject> prototype(JSObject::cast(constructor->instance_prototype()));
3687  SimpleInstallFunction(prototype, "finally", Builtins::kPromiseFinally, 1,
3688                        true, DONT_ENUM);
3689
3690  // The promise prototype map has changed because we added a property
3691  // to prototype, so we update the saved map.
3692  Handle<Map> prototype_map(prototype->map());
3693  Map::SetShouldBeFastPrototypeMap(prototype_map, true, isolate());
3694  native_context()->set_promise_prototype_map(*prototype_map);
3695
3696  {
3697    Handle<Code> code =
3698        handle(isolate()->builtins()->builtin(Builtins::kPromiseThenFinally),
3699               isolate());
3700    Handle<SharedFunctionInfo> info = factory()->NewSharedFunctionInfo(
3701        factory()->empty_string(), code, false);
3702    info->set_internal_formal_parameter_count(1);
3703    info->set_length(1);
3704    info->set_native(true);
3705    native_context()->set_promise_then_finally_shared_fun(*info);
3706  }
3707
3708  {
3709    Handle<Code> code =
3710        handle(isolate()->builtins()->builtin(Builtins::kPromiseCatchFinally),
3711               isolate());
3712    Handle<SharedFunctionInfo> info = factory()->NewSharedFunctionInfo(
3713        factory()->empty_string(), code, false);
3714    info->set_internal_formal_parameter_count(1);
3715    info->set_length(1);
3716    info->set_native(true);
3717    native_context()->set_promise_catch_finally_shared_fun(*info);
3718  }
3719
3720  {
3721    Handle<Code> code = handle(
3722        isolate()->builtins()->builtin(Builtins::kPromiseValueThunkFinally),
3723        isolate());
3724    Handle<SharedFunctionInfo> info = factory()->NewSharedFunctionInfo(
3725        factory()->empty_string(), code, false);
3726    info->set_internal_formal_parameter_count(0);
3727    info->set_length(0);
3728    native_context()->set_promise_value_thunk_finally_shared_fun(*info);
3729  }
3730
3731  {
3732    Handle<Code> code =
3733        handle(isolate()->builtins()->builtin(Builtins::kPromiseThrowerFinally),
3734               isolate());
3735    Handle<SharedFunctionInfo> info = factory()->NewSharedFunctionInfo(
3736        factory()->empty_string(), code, false);
3737    info->set_internal_formal_parameter_count(0);
3738    info->set_length(0);
3739    native_context()->set_promise_thrower_finally_shared_fun(*info);
3740  }
3741}
3742
3743#ifdef V8_I18N_SUPPORT
3744void Genesis::InitializeGlobal_datetime_format_to_parts() {
3745  if (!FLAG_datetime_format_to_parts) return;
3746  Handle<JSReceiver> exports_container(
3747      JSReceiver::cast(native_context()->exports_container()));
3748  Handle<JSObject> date_time_format_prototype(JSObject::cast(
3749      native_context()->intl_date_time_format_function()->prototype()));
3750  Handle<JSFunction> format_date_to_parts = Handle<JSFunction>::cast(
3751      JSReceiver::GetProperty(
3752          exports_container,
3753          factory()->InternalizeUtf8String("FormatDateToParts"))
3754          .ToHandleChecked());
3755  InstallFunction(date_time_format_prototype, format_date_to_parts,
3756                  factory()->InternalizeUtf8String("formatToParts"));
3757}
3758
3759namespace {
3760
3761void SetFunction(Handle<JSObject> target, Handle<JSFunction> function,
3762                 Handle<Name> name, PropertyAttributes attributes = DONT_ENUM) {
3763  JSObject::SetOwnPropertyIgnoreAttributes(target, name, function, attributes)
3764      .ToHandleChecked();
3765}
3766
3767}  // namespace
3768
3769void Genesis::InitializeGlobal_icu_case_mapping() {
3770  if (!FLAG_icu_case_mapping) return;
3771
3772  Handle<JSReceiver> exports_container(
3773      JSReceiver::cast(native_context()->exports_container()));
3774
3775  Handle<JSObject> string_prototype(
3776      JSObject::cast(native_context()->string_function()->prototype()));
3777
3778  Handle<JSFunction> to_lower_case = Handle<JSFunction>::cast(
3779      JSReceiver::GetProperty(
3780          exports_container,
3781          factory()->InternalizeUtf8String("ToLowerCaseI18N"))
3782          .ToHandleChecked());
3783  SetFunction(string_prototype, to_lower_case,
3784              factory()->InternalizeUtf8String("toLowerCase"));
3785
3786  Handle<JSFunction> to_upper_case = Handle<JSFunction>::cast(
3787      JSReceiver::GetProperty(
3788          exports_container,
3789          factory()->InternalizeUtf8String("ToUpperCaseI18N"))
3790          .ToHandleChecked());
3791  SetFunction(string_prototype, to_upper_case,
3792              factory()->InternalizeUtf8String("toUpperCase"));
3793
3794  Handle<JSFunction> to_locale_lower_case = Handle<JSFunction>::cast(
3795      JSReceiver::GetProperty(
3796          exports_container,
3797          factory()->InternalizeUtf8String("ToLocaleLowerCaseI18N"))
3798          .ToHandleChecked());
3799  SetFunction(string_prototype, to_locale_lower_case,
3800              factory()->InternalizeUtf8String("toLocaleLowerCase"));
3801
3802  Handle<JSFunction> to_locale_upper_case = Handle<JSFunction>::cast(
3803      JSReceiver::GetProperty(
3804          exports_container,
3805          factory()->InternalizeUtf8String("ToLocaleUpperCaseI18N"))
3806          .ToHandleChecked());
3807  SetFunction(string_prototype, to_locale_upper_case,
3808              factory()->InternalizeUtf8String("toLocaleUpperCase"));
3809}
3810#endif
3811
3812Handle<JSFunction> Genesis::InstallArrayBuffer(Handle<JSObject> target,
3813                                               const char* name,
3814                                               Builtins::Name call,
3815                                               BuiltinFunctionId id) {
3816  // Create the %ArrayBufferPrototype%
3817  // Setup the {prototype} with the given {name} for @@toStringTag.
3818  Handle<JSObject> prototype =
3819      factory()->NewJSObject(isolate()->object_function(), TENURED);
3820  JSObject::AddProperty(prototype, factory()->to_string_tag_symbol(),
3821                        factory()->NewStringFromAsciiChecked(name),
3822                        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
3823
3824  // Allocate the constructor with the given {prototype}.
3825  Handle<JSFunction> array_buffer_fun =
3826      InstallFunction(target, name, JS_ARRAY_BUFFER_TYPE,
3827                      JSArrayBuffer::kSizeWithInternalFields, prototype,
3828                      Builtins::kArrayBufferConstructor);
3829  array_buffer_fun->shared()->SetConstructStub(
3830      *isolate()->builtins()->ArrayBufferConstructor_ConstructStub());
3831  array_buffer_fun->shared()->DontAdaptArguments();
3832  array_buffer_fun->shared()->set_length(1);
3833
3834  // Install the "constructor" property on the {prototype}.
3835  JSObject::AddProperty(prototype, factory()->constructor_string(),
3836                        array_buffer_fun, DONT_ENUM);
3837
3838  SimpleInstallFunction(array_buffer_fun, factory()->isView_string(),
3839                        Builtins::kArrayBufferIsView, 1, true);
3840
3841  // Install the "byteLength" getter on the {prototype}.
3842  SimpleInstallGetter(prototype, factory()->byte_length_string(), call, false,
3843                      id);
3844
3845  return array_buffer_fun;
3846}
3847
3848
3849Handle<JSFunction> Genesis::InstallInternalArray(Handle<JSObject> target,
3850                                                 const char* name,
3851                                                 ElementsKind elements_kind) {
3852  // --- I n t e r n a l   A r r a y ---
3853  // An array constructor on the builtins object that works like
3854  // the public Array constructor, except that its prototype
3855  // doesn't inherit from Object.prototype.
3856  // To be used only for internal work by builtins. Instances
3857  // must not be leaked to user code.
3858  Handle<JSObject> prototype =
3859      factory()->NewJSObject(isolate()->object_function(), TENURED);
3860  Handle<JSFunction> array_function =
3861      InstallFunction(target, name, JS_ARRAY_TYPE, JSArray::kSize, prototype,
3862                      Builtins::kInternalArrayCode);
3863
3864  InternalArrayConstructorStub internal_array_constructor_stub(isolate());
3865  Handle<Code> code = internal_array_constructor_stub.GetCode();
3866  array_function->shared()->SetConstructStub(*code);
3867  array_function->shared()->DontAdaptArguments();
3868
3869  Handle<Map> original_map(array_function->initial_map());
3870  Handle<Map> initial_map = Map::Copy(original_map, "InternalArray");
3871  initial_map->set_elements_kind(elements_kind);
3872  JSFunction::SetInitialMap(array_function, initial_map, prototype);
3873
3874  // Make "length" magic on instances.
3875  Map::EnsureDescriptorSlack(initial_map, 1);
3876
3877  PropertyAttributes attribs = static_cast<PropertyAttributes>(
3878      DONT_ENUM | DONT_DELETE);
3879
3880  Handle<AccessorInfo> array_length =
3881      Accessors::ArrayLengthInfo(isolate(), attribs);
3882  {  // Add length.
3883    Descriptor d = Descriptor::AccessorConstant(
3884        Handle<Name>(Name::cast(array_length->name())), array_length, attribs);
3885    initial_map->AppendDescriptor(&d);
3886  }
3887
3888  return array_function;
3889}
3890
3891bool Genesis::InstallNatives(GlobalContextType context_type) {
3892  HandleScope scope(isolate());
3893
3894  // Set up the utils object as shared container between native scripts.
3895  Handle<JSObject> utils = factory()->NewJSObject(isolate()->object_function());
3896  JSObject::NormalizeProperties(utils, CLEAR_INOBJECT_PROPERTIES, 16,
3897                                "utils container for native scripts");
3898  native_context()->set_natives_utils_object(*utils);
3899
3900  // Set up the extras utils object as a shared container between native
3901  // scripts and extras. (Extras consume things added there by native scripts.)
3902  Handle<JSObject> extras_utils =
3903      factory()->NewJSObject(isolate()->object_function());
3904  native_context()->set_extras_utils_object(*extras_utils);
3905
3906  InstallInternalArray(extras_utils, "InternalPackedArray", FAST_ELEMENTS);
3907
3908  InstallFunction(extras_utils, isolate()->promise_internal_constructor(),
3909                  factory()->NewStringFromAsciiChecked("createPromise"));
3910  InstallFunction(extras_utils, isolate()->promise_resolve(),
3911                  factory()->NewStringFromAsciiChecked("resolvePromise"));
3912
3913  int builtin_index = Natives::GetDebuggerCount();
3914  // Only run prologue.js and runtime.js at this point.
3915  DCHECK_EQ(builtin_index, Natives::GetIndex("prologue"));
3916  if (!Bootstrapper::CompileBuiltin(isolate(), builtin_index++)) return false;
3917  DCHECK_EQ(builtin_index, Natives::GetIndex("runtime"));
3918  if (!Bootstrapper::CompileBuiltin(isolate(), builtin_index++)) return false;
3919
3920  {
3921    // Builtin function for OpaqueReference -- a JSValue-based object,
3922    // that keeps its field isolated from JavaScript code. It may store
3923    // objects, that JavaScript code may not access.
3924    Handle<JSFunction> opaque_reference_fun = factory()->NewFunction(
3925        factory()->empty_string(), isolate()->builtins()->Illegal(),
3926        isolate()->initial_object_prototype(), JS_VALUE_TYPE, JSValue::kSize);
3927    Handle<JSObject> prototype =
3928        factory()->NewJSObject(isolate()->object_function(), TENURED);
3929    Accessors::FunctionSetPrototype(opaque_reference_fun, prototype).Assert();
3930    native_context()->set_opaque_reference_function(*opaque_reference_fun);
3931  }
3932
3933  // InternalArrays should not use Smi-Only array optimizations. There are too
3934  // many places in the C++ runtime code (e.g. RegEx) that assume that
3935  // elements in InternalArrays can be set to non-Smi values without going
3936  // through a common bottleneck that would make the SMI_ONLY -> FAST_ELEMENT
3937  // transition easy to trap. Moreover, they rarely are smi-only.
3938  {
3939    HandleScope scope(isolate());
3940    Handle<JSObject> utils =
3941        Handle<JSObject>::cast(isolate()->natives_utils_object());
3942    Handle<JSFunction> array_function =
3943        InstallInternalArray(utils, "InternalArray", FAST_HOLEY_ELEMENTS);
3944    native_context()->set_internal_array_function(*array_function);
3945    InstallInternalArray(utils, "InternalPackedArray", FAST_ELEMENTS);
3946  }
3947
3948  // Run the rest of the native scripts.
3949  while (builtin_index < Natives::GetBuiltinsCount()) {
3950    if (!Bootstrapper::CompileBuiltin(isolate(), builtin_index++)) return false;
3951  }
3952
3953  if (!CallUtilsFunction(isolate(), "PostNatives")) return false;
3954  auto fast_template_instantiations_cache = isolate()->factory()->NewFixedArray(
3955      TemplateInfo::kFastTemplateInstantiationsCacheSize);
3956  native_context()->set_fast_template_instantiations_cache(
3957      *fast_template_instantiations_cache);
3958
3959  auto slow_template_instantiations_cache = UnseededNumberDictionary::New(
3960      isolate(), ApiNatives::kInitialFunctionCacheSize);
3961  native_context()->set_slow_template_instantiations_cache(
3962      *slow_template_instantiations_cache);
3963
3964  // Store the map for the %ObjectPrototype% after the natives has been compiled
3965  // and the Object function has been set up.
3966  Handle<JSFunction> object_function(native_context()->object_function());
3967  DCHECK(JSObject::cast(object_function->initial_map()->prototype())
3968             ->HasFastProperties());
3969  native_context()->set_object_function_prototype_map(
3970      HeapObject::cast(object_function->initial_map()->prototype())->map());
3971
3972  // Set up the map for Object.create(null) instances.
3973  Handle<Map> slow_object_with_null_prototype_map =
3974      Map::CopyInitialMap(handle(object_function->initial_map(), isolate()));
3975  slow_object_with_null_prototype_map->set_dictionary_map(true);
3976  Map::SetPrototype(slow_object_with_null_prototype_map,
3977                    isolate()->factory()->null_value());
3978  native_context()->set_slow_object_with_null_prototype_map(
3979      *slow_object_with_null_prototype_map);
3980
3981  // Store the map for the %StringPrototype% after the natives has been compiled
3982  // and the String function has been set up.
3983  Handle<JSFunction> string_function(native_context()->string_function());
3984  JSObject* string_function_prototype =
3985      JSObject::cast(string_function->initial_map()->prototype());
3986  DCHECK(string_function_prototype->HasFastProperties());
3987  native_context()->set_string_function_prototype_map(
3988      string_function_prototype->map());
3989
3990  Handle<JSGlobalObject> global_object =
3991      handle(native_context()->global_object());
3992
3993  // Install Global.decodeURI.
3994  SimpleInstallFunction(global_object, "decodeURI", Builtins::kGlobalDecodeURI,
3995                        1, false, kGlobalDecodeURI);
3996
3997  // Install Global.decodeURIComponent.
3998  SimpleInstallFunction(global_object, "decodeURIComponent",
3999                        Builtins::kGlobalDecodeURIComponent, 1, false,
4000                        kGlobalDecodeURIComponent);
4001
4002  // Install Global.encodeURI.
4003  SimpleInstallFunction(global_object, "encodeURI", Builtins::kGlobalEncodeURI,
4004                        1, false, kGlobalEncodeURI);
4005
4006  // Install Global.encodeURIComponent.
4007  SimpleInstallFunction(global_object, "encodeURIComponent",
4008                        Builtins::kGlobalEncodeURIComponent, 1, false,
4009                        kGlobalEncodeURIComponent);
4010
4011  // Install Global.escape.
4012  SimpleInstallFunction(global_object, "escape", Builtins::kGlobalEscape, 1,
4013                        false, kGlobalEscape);
4014
4015  // Install Global.unescape.
4016  SimpleInstallFunction(global_object, "unescape", Builtins::kGlobalUnescape, 1,
4017                        false, kGlobalUnescape);
4018
4019  // Install Global.eval.
4020  {
4021    Handle<JSFunction> eval =
4022        SimpleInstallFunction(global_object, factory()->eval_string(),
4023                              Builtins::kGlobalEval, 1, false);
4024    native_context()->set_global_eval_fun(*eval);
4025  }
4026
4027  // Install Global.isFinite
4028  SimpleInstallFunction(global_object, "isFinite", Builtins::kGlobalIsFinite, 1,
4029                        true, kGlobalIsFinite);
4030
4031  // Install Global.isNaN
4032  SimpleInstallFunction(global_object, "isNaN", Builtins::kGlobalIsNaN, 1, true,
4033                        kGlobalIsNaN);
4034
4035  // Install Array.prototype.concat
4036  {
4037    Handle<JSFunction> array_constructor(native_context()->array_function());
4038    Handle<JSObject> proto(JSObject::cast(array_constructor->prototype()));
4039    Handle<JSFunction> concat =
4040        InstallFunction(proto, "concat", JS_OBJECT_TYPE, JSObject::kHeaderSize,
4041                        MaybeHandle<JSObject>(), Builtins::kArrayConcat);
4042
4043    // Make sure that Array.prototype.concat appears to be compiled.
4044    // The code will never be called, but inline caching for call will
4045    // only work if it appears to be compiled.
4046    concat->shared()->DontAdaptArguments();
4047    DCHECK(concat->is_compiled());
4048    // Set the lengths for the functions to satisfy ECMA-262.
4049    concat->shared()->set_length(1);
4050  }
4051
4052  // Install InternalArray.prototype.concat
4053  {
4054    Handle<JSFunction> array_constructor(
4055        native_context()->internal_array_function());
4056    Handle<JSObject> proto(JSObject::cast(array_constructor->prototype()));
4057    Handle<JSFunction> concat =
4058        InstallFunction(proto, "concat", JS_OBJECT_TYPE, JSObject::kHeaderSize,
4059                        MaybeHandle<JSObject>(), Builtins::kArrayConcat);
4060
4061    // Make sure that InternalArray.prototype.concat appears to be compiled.
4062    // The code will never be called, but inline caching for call will
4063    // only work if it appears to be compiled.
4064    concat->shared()->DontAdaptArguments();
4065    DCHECK(concat->is_compiled());
4066    // Set the lengths for the functions to satisfy ECMA-262.
4067    concat->shared()->set_length(1);
4068  }
4069
4070  InstallBuiltinFunctionIds();
4071
4072  // Create a map for accessor property descriptors (a variant of JSObject
4073  // that predefines four properties get, set, configurable and enumerable).
4074  {
4075    // AccessorPropertyDescriptor initial map.
4076    Handle<Map> map =
4077        factory()->NewMap(JS_OBJECT_TYPE, JSAccessorPropertyDescriptor::kSize);
4078    // Create the descriptor array for the property descriptor object.
4079    Map::EnsureDescriptorSlack(map, 4);
4080
4081    {  // get
4082      Descriptor d = Descriptor::DataField(
4083          factory()->get_string(), JSAccessorPropertyDescriptor::kGetIndex,
4084          NONE, Representation::Tagged());
4085      map->AppendDescriptor(&d);
4086    }
4087    {  // set
4088      Descriptor d = Descriptor::DataField(
4089          factory()->set_string(), JSAccessorPropertyDescriptor::kSetIndex,
4090          NONE, Representation::Tagged());
4091      map->AppendDescriptor(&d);
4092    }
4093    {  // enumerable
4094      Descriptor d =
4095          Descriptor::DataField(factory()->enumerable_string(),
4096                                JSAccessorPropertyDescriptor::kEnumerableIndex,
4097                                NONE, Representation::Tagged());
4098      map->AppendDescriptor(&d);
4099    }
4100    {  // configurable
4101      Descriptor d = Descriptor::DataField(
4102          factory()->configurable_string(),
4103          JSAccessorPropertyDescriptor::kConfigurableIndex, NONE,
4104          Representation::Tagged());
4105      map->AppendDescriptor(&d);
4106    }
4107
4108    Map::SetPrototype(map, isolate()->initial_object_prototype());
4109    map->SetConstructor(native_context()->object_function());
4110    map->SetInObjectProperties(4);
4111    map->set_unused_property_fields(0);
4112
4113    native_context()->set_accessor_property_descriptor_map(*map);
4114  }
4115
4116  // Create a map for data property descriptors (a variant of JSObject
4117  // that predefines four properties value, writable, configurable and
4118  // enumerable).
4119  {
4120    // DataPropertyDescriptor initial map.
4121    Handle<Map> map =
4122        factory()->NewMap(JS_OBJECT_TYPE, JSDataPropertyDescriptor::kSize);
4123    // Create the descriptor array for the property descriptor object.
4124    Map::EnsureDescriptorSlack(map, 4);
4125
4126    {  // value
4127      Descriptor d = Descriptor::DataField(
4128          factory()->value_string(), JSDataPropertyDescriptor::kValueIndex,
4129          NONE, Representation::Tagged());
4130      map->AppendDescriptor(&d);
4131    }
4132    {  // writable
4133      Descriptor d =
4134          Descriptor::DataField(factory()->writable_string(),
4135                                JSDataPropertyDescriptor::kWritableIndex, NONE,
4136                                Representation::Tagged());
4137      map->AppendDescriptor(&d);
4138    }
4139    {  // enumerable
4140      Descriptor d =
4141          Descriptor::DataField(factory()->enumerable_string(),
4142                                JSDataPropertyDescriptor::kEnumerableIndex,
4143                                NONE, Representation::Tagged());
4144      map->AppendDescriptor(&d);
4145    }
4146    {  // configurable
4147      Descriptor d =
4148          Descriptor::DataField(factory()->configurable_string(),
4149                                JSDataPropertyDescriptor::kConfigurableIndex,
4150                                NONE, Representation::Tagged());
4151      map->AppendDescriptor(&d);
4152    }
4153
4154    Map::SetPrototype(map, isolate()->initial_object_prototype());
4155    map->SetConstructor(native_context()->object_function());
4156    map->SetInObjectProperties(4);
4157    map->set_unused_property_fields(0);
4158
4159    native_context()->set_data_property_descriptor_map(*map);
4160  }
4161
4162  // Create a constructor for RegExp results (a variant of Array that
4163  // predefines the two properties index and match).
4164  {
4165    // RegExpResult initial map.
4166
4167    // Find global.Array.prototype to inherit from.
4168    Handle<JSFunction> array_constructor(native_context()->array_function());
4169    Handle<JSObject> array_prototype(
4170        JSObject::cast(array_constructor->instance_prototype()));
4171
4172    // Add initial map.
4173    Handle<Map> initial_map =
4174        factory()->NewMap(JS_ARRAY_TYPE, JSRegExpResult::kSize);
4175    initial_map->SetConstructor(*array_constructor);
4176
4177    // Set prototype on map.
4178    initial_map->set_non_instance_prototype(false);
4179    Map::SetPrototype(initial_map, array_prototype);
4180
4181    // Update map with length accessor from Array and add "index" and "input".
4182    Map::EnsureDescriptorSlack(initial_map, 3);
4183
4184    {
4185      JSFunction* array_function = native_context()->array_function();
4186      Handle<DescriptorArray> array_descriptors(
4187          array_function->initial_map()->instance_descriptors());
4188      Handle<String> length = factory()->length_string();
4189      int old = array_descriptors->SearchWithCache(
4190          isolate(), *length, array_function->initial_map());
4191      DCHECK(old != DescriptorArray::kNotFound);
4192      Descriptor d = Descriptor::AccessorConstant(
4193          length, handle(array_descriptors->GetValue(old), isolate()),
4194          array_descriptors->GetDetails(old).attributes());
4195      initial_map->AppendDescriptor(&d);
4196    }
4197    {
4198      Descriptor d = Descriptor::DataField(factory()->index_string(),
4199                                           JSRegExpResult::kIndexIndex, NONE,
4200                                           Representation::Tagged());
4201      initial_map->AppendDescriptor(&d);
4202    }
4203
4204    {
4205      Descriptor d = Descriptor::DataField(factory()->input_string(),
4206                                           JSRegExpResult::kInputIndex, NONE,
4207                                           Representation::Tagged());
4208      initial_map->AppendDescriptor(&d);
4209    }
4210
4211    initial_map->SetInObjectProperties(2);
4212    initial_map->set_unused_property_fields(0);
4213
4214    native_context()->set_regexp_result_map(*initial_map);
4215  }
4216
4217  // Add @@iterator method to the arguments object maps.
4218  {
4219    PropertyAttributes attribs = DONT_ENUM;
4220    Handle<AccessorInfo> arguments_iterator =
4221        Accessors::ArgumentsIteratorInfo(isolate(), attribs);
4222    {
4223      Descriptor d = Descriptor::AccessorConstant(factory()->iterator_symbol(),
4224                                                  arguments_iterator, attribs);
4225      Handle<Map> map(native_context()->sloppy_arguments_map());
4226      Map::EnsureDescriptorSlack(map, 1);
4227      map->AppendDescriptor(&d);
4228    }
4229    {
4230      Descriptor d = Descriptor::AccessorConstant(factory()->iterator_symbol(),
4231                                                  arguments_iterator, attribs);
4232      Handle<Map> map(native_context()->fast_aliased_arguments_map());
4233      Map::EnsureDescriptorSlack(map, 1);
4234      map->AppendDescriptor(&d);
4235    }
4236    {
4237      Descriptor d = Descriptor::AccessorConstant(factory()->iterator_symbol(),
4238                                                  arguments_iterator, attribs);
4239      Handle<Map> map(native_context()->slow_aliased_arguments_map());
4240      Map::EnsureDescriptorSlack(map, 1);
4241      map->AppendDescriptor(&d);
4242    }
4243    {
4244      Descriptor d = Descriptor::AccessorConstant(factory()->iterator_symbol(),
4245                                                  arguments_iterator, attribs);
4246      Handle<Map> map(native_context()->strict_arguments_map());
4247      Map::EnsureDescriptorSlack(map, 1);
4248      map->AppendDescriptor(&d);
4249    }
4250  }
4251
4252  return true;
4253}
4254
4255
4256bool Genesis::InstallExperimentalNatives() {
4257  static const char* harmony_tailcalls_natives[] = {nullptr};
4258  static const char* harmony_sharedarraybuffer_natives[] = {
4259      "native harmony-atomics.js", NULL};
4260  static const char* harmony_do_expressions_natives[] = {nullptr};
4261  static const char* harmony_regexp_lookbehind_natives[] = {nullptr};
4262  static const char* harmony_regexp_named_captures_natives[] = {nullptr};
4263  static const char* harmony_regexp_property_natives[] = {nullptr};
4264  static const char* harmony_function_sent_natives[] = {nullptr};
4265  static const char* harmony_array_prototype_values_natives[] = {nullptr};
4266#ifdef V8_I18N_SUPPORT
4267  static const char* icu_case_mapping_natives[] = {nullptr};
4268  static const char* datetime_format_to_parts_natives[] = {nullptr};
4269#endif
4270  static const char* harmony_restrictive_generators_natives[] = {nullptr};
4271  static const char* harmony_trailing_commas_natives[] = {nullptr};
4272  static const char* harmony_function_tostring_natives[] = {nullptr};
4273  static const char* harmony_class_fields_natives[] = {nullptr};
4274  static const char* harmony_object_rest_spread_natives[] = {nullptr};
4275  static const char* harmony_async_iteration_natives[] = {nullptr};
4276  static const char* harmony_dynamic_import_natives[] = {nullptr};
4277  static const char* harmony_promise_finally_natives[] = {nullptr};
4278  static const char* harmony_template_escapes_natives[] = {nullptr};
4279
4280  for (int i = ExperimentalNatives::GetDebuggerCount();
4281       i < ExperimentalNatives::GetBuiltinsCount(); i++) {
4282#define INSTALL_EXPERIMENTAL_NATIVES(id, desc)                                \
4283  if (FLAG_##id) {                                                            \
4284    for (size_t j = 0; id##_natives[j] != NULL; j++) {                        \
4285      Vector<const char> script_name = ExperimentalNatives::GetScriptName(i); \
4286      if (strncmp(script_name.start(), id##_natives[j],                       \
4287                  script_name.length()) == 0) {                               \
4288        if (!Bootstrapper::CompileExperimentalBuiltin(isolate(), i)) {        \
4289          return false;                                                       \
4290        }                                                                     \
4291      }                                                                       \
4292    }                                                                         \
4293  }
4294    HARMONY_INPROGRESS(INSTALL_EXPERIMENTAL_NATIVES);
4295    HARMONY_STAGED(INSTALL_EXPERIMENTAL_NATIVES);
4296    HARMONY_SHIPPING(INSTALL_EXPERIMENTAL_NATIVES);
4297#undef INSTALL_EXPERIMENTAL_NATIVES
4298  }
4299
4300  if (!CallUtilsFunction(isolate(), "PostExperimentals")) return false;
4301
4302  InstallExperimentalBuiltinFunctionIds();
4303  return true;
4304}
4305
4306
4307bool Genesis::InstallExtraNatives() {
4308  HandleScope scope(isolate());
4309
4310  Handle<JSObject> extras_binding =
4311      factory()->NewJSObject(isolate()->object_function());
4312  native_context()->set_extras_binding_object(*extras_binding);
4313
4314  for (int i = ExtraNatives::GetDebuggerCount();
4315       i < ExtraNatives::GetBuiltinsCount(); i++) {
4316    if (!Bootstrapper::CompileExtraBuiltin(isolate(), i)) return false;
4317  }
4318
4319  return true;
4320}
4321
4322
4323bool Genesis::InstallExperimentalExtraNatives() {
4324  for (int i = ExperimentalExtraNatives::GetDebuggerCount();
4325       i < ExperimentalExtraNatives::GetBuiltinsCount(); i++) {
4326    if (!Bootstrapper::CompileExperimentalExtraBuiltin(isolate(), i))
4327      return false;
4328  }
4329
4330  return true;
4331}
4332
4333
4334bool Genesis::InstallDebuggerNatives() {
4335  for (int i = 0; i < Natives::GetDebuggerCount(); ++i) {
4336    if (!Bootstrapper::CompileBuiltin(isolate(), i)) return false;
4337  }
4338  return CallUtilsFunction(isolate(), "PostDebug");
4339}
4340
4341
4342static void InstallBuiltinFunctionId(Handle<JSObject> holder,
4343                                     const char* function_name,
4344                                     BuiltinFunctionId id) {
4345  Isolate* isolate = holder->GetIsolate();
4346  Handle<Object> function_object =
4347      JSReceiver::GetProperty(isolate, holder, function_name).ToHandleChecked();
4348  Handle<JSFunction> function = Handle<JSFunction>::cast(function_object);
4349  function->shared()->set_builtin_function_id(id);
4350}
4351
4352
4353#define INSTALL_BUILTIN_ID(holder_expr, fun_name, name) \
4354  { #holder_expr, #fun_name, k##name }                  \
4355  ,
4356
4357
4358void Genesis::InstallBuiltinFunctionIds() {
4359  HandleScope scope(isolate());
4360  struct BuiltinFunctionIds {
4361    const char* holder_expr;
4362    const char* fun_name;
4363    BuiltinFunctionId id;
4364  };
4365
4366  const BuiltinFunctionIds builtins[] = {
4367      FUNCTIONS_WITH_ID_LIST(INSTALL_BUILTIN_ID)};
4368
4369  for (const BuiltinFunctionIds& builtin : builtins) {
4370    Handle<JSObject> holder =
4371        ResolveBuiltinIdHolder(native_context(), builtin.holder_expr);
4372    InstallBuiltinFunctionId(holder, builtin.fun_name, builtin.id);
4373  }
4374}
4375
4376
4377void Genesis::InstallExperimentalBuiltinFunctionIds() {
4378  if (FLAG_harmony_sharedarraybuffer) {
4379    struct BuiltinFunctionIds {
4380      const char* holder_expr;
4381      const char* fun_name;
4382      BuiltinFunctionId id;
4383    };
4384
4385    const BuiltinFunctionIds atomic_builtins[] = {
4386        ATOMIC_FUNCTIONS_WITH_ID_LIST(INSTALL_BUILTIN_ID)};
4387
4388    for (const BuiltinFunctionIds& builtin : atomic_builtins) {
4389      Handle<JSObject> holder =
4390          ResolveBuiltinIdHolder(native_context(), builtin.holder_expr);
4391      InstallBuiltinFunctionId(holder, builtin.fun_name, builtin.id);
4392    }
4393  }
4394}
4395
4396#undef INSTALL_BUILTIN_ID
4397
4398
4399void Genesis::InitializeNormalizedMapCaches() {
4400  Handle<NormalizedMapCache> cache = NormalizedMapCache::New(isolate());
4401  native_context()->set_normalized_map_cache(*cache);
4402}
4403
4404
4405bool Bootstrapper::InstallExtensions(Handle<Context> native_context,
4406                                     v8::ExtensionConfiguration* extensions) {
4407  BootstrapperActive active(this);
4408  SaveContext saved_context(isolate_);
4409  isolate_->set_context(*native_context);
4410  return Genesis::InstallExtensions(native_context, extensions) &&
4411      Genesis::InstallSpecialObjects(native_context);
4412}
4413
4414
4415bool Genesis::InstallSpecialObjects(Handle<Context> native_context) {
4416  Isolate* isolate = native_context->GetIsolate();
4417  // Don't install extensions into the snapshot.
4418  if (isolate->serializer_enabled()) return true;
4419
4420  Factory* factory = isolate->factory();
4421  HandleScope scope(isolate);
4422
4423  Handle<JSObject> Error = isolate->error_function();
4424  Handle<String> name =
4425      factory->InternalizeOneByteString(STATIC_CHAR_VECTOR("stackTraceLimit"));
4426  Handle<Smi> stack_trace_limit(Smi::FromInt(FLAG_stack_trace_limit), isolate);
4427  JSObject::AddProperty(Error, name, stack_trace_limit, NONE);
4428
4429  if (FLAG_expose_wasm || FLAG_validate_asm) {
4430    WasmJs::Install(isolate);
4431  }
4432
4433  InstallFFIMap(isolate);
4434
4435  return true;
4436}
4437
4438
4439static uint32_t Hash(RegisteredExtension* extension) {
4440  return v8::internal::ComputePointerHash(extension);
4441}
4442
4443Genesis::ExtensionStates::ExtensionStates() : map_(8) {}
4444
4445Genesis::ExtensionTraversalState Genesis::ExtensionStates::get_state(
4446    RegisteredExtension* extension) {
4447  base::HashMap::Entry* entry = map_.Lookup(extension, Hash(extension));
4448  if (entry == NULL) {
4449    return UNVISITED;
4450  }
4451  return static_cast<ExtensionTraversalState>(
4452      reinterpret_cast<intptr_t>(entry->value));
4453}
4454
4455void Genesis::ExtensionStates::set_state(RegisteredExtension* extension,
4456                                         ExtensionTraversalState state) {
4457  map_.LookupOrInsert(extension, Hash(extension))->value =
4458      reinterpret_cast<void*>(static_cast<intptr_t>(state));
4459}
4460
4461
4462bool Genesis::InstallExtensions(Handle<Context> native_context,
4463                                v8::ExtensionConfiguration* extensions) {
4464  Isolate* isolate = native_context->GetIsolate();
4465  ExtensionStates extension_states;  // All extensions have state UNVISITED.
4466  return InstallAutoExtensions(isolate, &extension_states) &&
4467         (!FLAG_expose_free_buffer ||
4468          InstallExtension(isolate, "v8/free-buffer", &extension_states)) &&
4469         (!FLAG_expose_gc ||
4470          InstallExtension(isolate, "v8/gc", &extension_states)) &&
4471         (!FLAG_expose_externalize_string ||
4472          InstallExtension(isolate, "v8/externalize", &extension_states)) &&
4473         (!FLAG_gc_stats ||
4474          InstallExtension(isolate, "v8/statistics", &extension_states)) &&
4475         (!FLAG_expose_trigger_failure ||
4476          InstallExtension(isolate, "v8/trigger-failure", &extension_states)) &&
4477         (!FLAG_trace_ignition_dispatches ||
4478          InstallExtension(isolate, "v8/ignition-statistics",
4479                           &extension_states)) &&
4480         InstallRequestedExtensions(isolate, extensions, &extension_states);
4481}
4482
4483
4484bool Genesis::InstallAutoExtensions(Isolate* isolate,
4485                                    ExtensionStates* extension_states) {
4486  for (v8::RegisteredExtension* it = v8::RegisteredExtension::first_extension();
4487       it != NULL;
4488       it = it->next()) {
4489    if (it->extension()->auto_enable() &&
4490        !InstallExtension(isolate, it, extension_states)) {
4491      return false;
4492    }
4493  }
4494  return true;
4495}
4496
4497
4498bool Genesis::InstallRequestedExtensions(Isolate* isolate,
4499                                         v8::ExtensionConfiguration* extensions,
4500                                         ExtensionStates* extension_states) {
4501  for (const char** it = extensions->begin(); it != extensions->end(); ++it) {
4502    if (!InstallExtension(isolate, *it, extension_states)) return false;
4503  }
4504  return true;
4505}
4506
4507
4508// Installs a named extension.  This methods is unoptimized and does
4509// not scale well if we want to support a large number of extensions.
4510bool Genesis::InstallExtension(Isolate* isolate,
4511                               const char* name,
4512                               ExtensionStates* extension_states) {
4513  for (v8::RegisteredExtension* it = v8::RegisteredExtension::first_extension();
4514       it != NULL;
4515       it = it->next()) {
4516    if (strcmp(name, it->extension()->name()) == 0) {
4517      return InstallExtension(isolate, it, extension_states);
4518    }
4519  }
4520  return Utils::ApiCheck(false,
4521                         "v8::Context::New()",
4522                         "Cannot find required extension");
4523}
4524
4525
4526bool Genesis::InstallExtension(Isolate* isolate,
4527                               v8::RegisteredExtension* current,
4528                               ExtensionStates* extension_states) {
4529  HandleScope scope(isolate);
4530
4531  if (extension_states->get_state(current) == INSTALLED) return true;
4532  // The current node has already been visited so there must be a
4533  // cycle in the dependency graph; fail.
4534  if (!Utils::ApiCheck(extension_states->get_state(current) != VISITED,
4535                       "v8::Context::New()",
4536                       "Circular extension dependency")) {
4537    return false;
4538  }
4539  DCHECK(extension_states->get_state(current) == UNVISITED);
4540  extension_states->set_state(current, VISITED);
4541  v8::Extension* extension = current->extension();
4542  // Install the extension's dependencies
4543  for (int i = 0; i < extension->dependency_count(); i++) {
4544    if (!InstallExtension(isolate,
4545                          extension->dependencies()[i],
4546                          extension_states)) {
4547      return false;
4548    }
4549  }
4550  // We do not expect this to throw an exception. Change this if it does.
4551  bool result = CompileExtension(isolate, extension);
4552  DCHECK(isolate->has_pending_exception() != result);
4553  if (!result) {
4554    // We print out the name of the extension that fail to install.
4555    // When an error is thrown during bootstrapping we automatically print
4556    // the line number at which this happened to the console in the isolate
4557    // error throwing functionality.
4558    base::OS::PrintError("Error installing extension '%s'.\n",
4559                         current->extension()->name());
4560    isolate->clear_pending_exception();
4561  }
4562  extension_states->set_state(current, INSTALLED);
4563  return result;
4564}
4565
4566
4567bool Genesis::ConfigureGlobalObjects(
4568    v8::Local<v8::ObjectTemplate> global_proxy_template) {
4569  Handle<JSObject> global_proxy(
4570      JSObject::cast(native_context()->global_proxy()));
4571  Handle<JSObject> global_object(
4572      JSObject::cast(native_context()->global_object()));
4573
4574  if (!global_proxy_template.IsEmpty()) {
4575    // Configure the global proxy object.
4576    Handle<ObjectTemplateInfo> global_proxy_data =
4577        v8::Utils::OpenHandle(*global_proxy_template);
4578    if (!ConfigureApiObject(global_proxy, global_proxy_data)) return false;
4579
4580    // Configure the global object.
4581    Handle<FunctionTemplateInfo> proxy_constructor(
4582        FunctionTemplateInfo::cast(global_proxy_data->constructor()));
4583    if (!proxy_constructor->prototype_template()->IsUndefined(isolate())) {
4584      Handle<ObjectTemplateInfo> global_object_data(
4585          ObjectTemplateInfo::cast(proxy_constructor->prototype_template()));
4586      if (!ConfigureApiObject(global_object, global_object_data)) return false;
4587    }
4588  }
4589
4590  JSObject::ForceSetPrototype(global_proxy, global_object);
4591
4592  native_context()->set_initial_array_prototype(
4593      JSArray::cast(native_context()->array_function()->prototype()));
4594  native_context()->set_array_buffer_map(
4595      native_context()->array_buffer_fun()->initial_map());
4596  native_context()->set_js_map_map(
4597      native_context()->js_map_fun()->initial_map());
4598  native_context()->set_js_set_map(
4599      native_context()->js_set_fun()->initial_map());
4600
4601  return true;
4602}
4603
4604
4605bool Genesis::ConfigureApiObject(Handle<JSObject> object,
4606                                 Handle<ObjectTemplateInfo> object_template) {
4607  DCHECK(!object_template.is_null());
4608  DCHECK(FunctionTemplateInfo::cast(object_template->constructor())
4609             ->IsTemplateFor(object->map()));;
4610
4611  MaybeHandle<JSObject> maybe_obj =
4612      ApiNatives::InstantiateObject(object_template);
4613  Handle<JSObject> obj;
4614  if (!maybe_obj.ToHandle(&obj)) {
4615    DCHECK(isolate()->has_pending_exception());
4616    isolate()->clear_pending_exception();
4617    return false;
4618  }
4619  TransferObject(obj, object);
4620  return true;
4621}
4622
4623
4624void Genesis::TransferNamedProperties(Handle<JSObject> from,
4625                                      Handle<JSObject> to) {
4626  // If JSObject::AddProperty asserts due to already existing property,
4627  // it is likely due to both global objects sharing property name(s).
4628  // Merging those two global objects is impossible.
4629  // The global template must not create properties that already exist
4630  // in the snapshotted global object.
4631  if (from->HasFastProperties()) {
4632    Handle<DescriptorArray> descs =
4633        Handle<DescriptorArray>(from->map()->instance_descriptors());
4634    for (int i = 0; i < from->map()->NumberOfOwnDescriptors(); i++) {
4635      PropertyDetails details = descs->GetDetails(i);
4636      if (details.location() == kField) {
4637        if (details.kind() == kData) {
4638          HandleScope inner(isolate());
4639          Handle<Name> key = Handle<Name>(descs->GetKey(i));
4640          FieldIndex index = FieldIndex::ForDescriptor(from->map(), i);
4641          DCHECK(!descs->GetDetails(i).representation().IsDouble());
4642          Handle<Object> value(from->RawFastPropertyAt(index), isolate());
4643          JSObject::AddProperty(to, key, value, details.attributes());
4644        } else {
4645          DCHECK_EQ(kAccessor, details.kind());
4646          UNREACHABLE();
4647        }
4648
4649      } else {
4650        DCHECK_EQ(kDescriptor, details.location());
4651        if (details.kind() == kData) {
4652          DCHECK(!FLAG_track_constant_fields);
4653          HandleScope inner(isolate());
4654          Handle<Name> key = Handle<Name>(descs->GetKey(i));
4655          Handle<Object> value(descs->GetValue(i), isolate());
4656          JSObject::AddProperty(to, key, value, details.attributes());
4657
4658        } else {
4659          DCHECK_EQ(kAccessor, details.kind());
4660          Handle<Name> key(descs->GetKey(i));
4661          LookupIterator it(to, key, LookupIterator::OWN_SKIP_INTERCEPTOR);
4662          CHECK_NE(LookupIterator::ACCESS_CHECK, it.state());
4663          // If the property is already there we skip it
4664          if (it.IsFound()) continue;
4665          HandleScope inner(isolate());
4666          DCHECK(!to->HasFastProperties());
4667          // Add to dictionary.
4668          Handle<Object> value(descs->GetValue(i), isolate());
4669          PropertyDetails d(kAccessor, details.attributes(), i + 1,
4670                            PropertyCellType::kMutable);
4671          JSObject::SetNormalizedProperty(to, key, value, d);
4672        }
4673      }
4674    }
4675  } else if (from->IsJSGlobalObject()) {
4676    // Copy all keys and values in enumeration order.
4677    Handle<GlobalDictionary> properties =
4678        Handle<GlobalDictionary>(from->global_dictionary());
4679    Handle<FixedArray> key_indices =
4680        GlobalDictionary::IterationIndices(properties);
4681    for (int i = 0; i < key_indices->length(); i++) {
4682      int key_index = Smi::cast(key_indices->get(i))->value();
4683      Object* raw_key = properties->KeyAt(key_index);
4684      DCHECK(properties->IsKey(isolate(), raw_key));
4685      DCHECK(raw_key->IsName());
4686      // If the property is already there we skip it.
4687      Handle<Name> key(Name::cast(raw_key), isolate());
4688      LookupIterator it(to, key, LookupIterator::OWN_SKIP_INTERCEPTOR);
4689      CHECK_NE(LookupIterator::ACCESS_CHECK, it.state());
4690      if (it.IsFound()) continue;
4691      // Set the property.
4692      DCHECK(properties->ValueAt(key_index)->IsPropertyCell());
4693      Handle<PropertyCell> cell(
4694          PropertyCell::cast(properties->ValueAt(key_index)), isolate());
4695      Handle<Object> value(cell->value(), isolate());
4696      if (value->IsTheHole(isolate())) continue;
4697      PropertyDetails details = cell->property_details();
4698      if (details.kind() != kData) continue;
4699      JSObject::AddProperty(to, key, value, details.attributes());
4700    }
4701  } else {
4702    // Copy all keys and values in enumeration order.
4703    Handle<NameDictionary> properties =
4704        Handle<NameDictionary>(from->property_dictionary());
4705    Handle<FixedArray> key_indices =
4706        NameDictionary::IterationIndices(properties);
4707    for (int i = 0; i < key_indices->length(); i++) {
4708      int key_index = Smi::cast(key_indices->get(i))->value();
4709      Object* raw_key = properties->KeyAt(key_index);
4710      DCHECK(properties->IsKey(isolate(), raw_key));
4711      DCHECK(raw_key->IsName());
4712      // If the property is already there we skip it.
4713      Handle<Name> key(Name::cast(raw_key), isolate());
4714      LookupIterator it(to, key, LookupIterator::OWN_SKIP_INTERCEPTOR);
4715      CHECK_NE(LookupIterator::ACCESS_CHECK, it.state());
4716      if (it.IsFound()) continue;
4717      // Set the property.
4718      Handle<Object> value =
4719          Handle<Object>(properties->ValueAt(key_index), isolate());
4720      DCHECK(!value->IsCell());
4721      DCHECK(!value->IsTheHole(isolate()));
4722      PropertyDetails details = properties->DetailsAt(key_index);
4723      DCHECK_EQ(kData, details.kind());
4724      JSObject::AddProperty(to, key, value, details.attributes());
4725    }
4726  }
4727}
4728
4729
4730void Genesis::TransferIndexedProperties(Handle<JSObject> from,
4731                                        Handle<JSObject> to) {
4732  // Cloning the elements array is sufficient.
4733  Handle<FixedArray> from_elements =
4734      Handle<FixedArray>(FixedArray::cast(from->elements()));
4735  Handle<FixedArray> to_elements = factory()->CopyFixedArray(from_elements);
4736  to->set_elements(*to_elements);
4737}
4738
4739
4740void Genesis::TransferObject(Handle<JSObject> from, Handle<JSObject> to) {
4741  HandleScope outer(isolate());
4742
4743  DCHECK(!from->IsJSArray());
4744  DCHECK(!to->IsJSArray());
4745
4746  TransferNamedProperties(from, to);
4747  TransferIndexedProperties(from, to);
4748
4749  // Transfer the prototype (new map is needed).
4750  Handle<Object> proto(from->map()->prototype(), isolate());
4751  JSObject::ForceSetPrototype(to, proto);
4752}
4753
4754
4755void Genesis::MakeFunctionInstancePrototypeWritable() {
4756  // The maps with writable prototype are created in CreateEmptyFunction
4757  // and CreateStrictModeFunctionMaps respectively. Initially the maps are
4758  // created with read-only prototype for JS builtins processing.
4759  DCHECK(!sloppy_function_map_writable_prototype_.is_null());
4760  DCHECK(!strict_function_map_writable_prototype_.is_null());
4761
4762  // Replace function instance maps to make prototype writable.
4763  native_context()->set_sloppy_function_map(
4764      *sloppy_function_map_writable_prototype_);
4765  native_context()->set_strict_function_map(
4766      *strict_function_map_writable_prototype_);
4767}
4768
4769
4770class NoTrackDoubleFieldsForSerializerScope {
4771 public:
4772  explicit NoTrackDoubleFieldsForSerializerScope(Isolate* isolate)
4773      : flag_(FLAG_track_double_fields), enabled_(false) {
4774    if (isolate->serializer_enabled()) {
4775      // Disable tracking double fields because heap numbers treated as
4776      // immutable by the serializer.
4777      FLAG_track_double_fields = false;
4778      enabled_ = true;
4779    }
4780  }
4781
4782  ~NoTrackDoubleFieldsForSerializerScope() {
4783    if (enabled_) {
4784      FLAG_track_double_fields = flag_;
4785    }
4786  }
4787
4788 private:
4789  bool flag_;
4790  bool enabled_;
4791};
4792
4793Genesis::Genesis(
4794    Isolate* isolate, MaybeHandle<JSGlobalProxy> maybe_global_proxy,
4795    v8::Local<v8::ObjectTemplate> global_proxy_template,
4796    size_t context_snapshot_index,
4797    v8::DeserializeInternalFieldsCallback internal_fields_deserializer,
4798    GlobalContextType context_type)
4799    : isolate_(isolate), active_(isolate->bootstrapper()) {
4800  NoTrackDoubleFieldsForSerializerScope disable_scope(isolate);
4801  result_ = Handle<Context>::null();
4802  global_proxy_ = Handle<JSGlobalProxy>::null();
4803
4804  // Before creating the roots we must save the context and restore it
4805  // on all function exits.
4806  SaveContext saved_context(isolate);
4807
4808  // During genesis, the boilerplate for stack overflow won't work until the
4809  // environment has been at least partially initialized. Add a stack check
4810  // before entering JS code to catch overflow early.
4811  StackLimitCheck check(isolate);
4812  if (check.HasOverflowed()) {
4813    isolate->StackOverflow();
4814    return;
4815  }
4816
4817  // The deserializer needs to hook up references to the global proxy.
4818  // Create an uninitialized global proxy now if we don't have one
4819  // and initialize it later in CreateNewGlobals.
4820  Handle<JSGlobalProxy> global_proxy;
4821  if (!maybe_global_proxy.ToHandle(&global_proxy)) {
4822    int instance_size = 0;
4823    if (context_snapshot_index > 0) {
4824      // The global proxy function to reinitialize this global proxy is in the
4825      // context that is yet to be deserialized. We need to prepare a global
4826      // proxy of the correct size.
4827      Object* size = isolate->heap()->serialized_global_proxy_sizes()->get(
4828          static_cast<int>(context_snapshot_index) - 1);
4829      instance_size = Smi::cast(size)->value();
4830    } else {
4831      instance_size = JSGlobalProxy::SizeWithInternalFields(
4832          global_proxy_template.IsEmpty()
4833              ? 0
4834              : global_proxy_template->InternalFieldCount());
4835    }
4836    global_proxy =
4837        isolate->factory()->NewUninitializedJSGlobalProxy(instance_size);
4838  }
4839
4840  // We can only de-serialize a context if the isolate was initialized from
4841  // a snapshot. Otherwise we have to build the context from scratch.
4842  // Also create a context from scratch to expose natives, if required by flag.
4843  if (!isolate->initialized_from_snapshot() ||
4844      !Snapshot::NewContextFromSnapshot(isolate, global_proxy,
4845                                        context_snapshot_index,
4846                                        internal_fields_deserializer)
4847           .ToHandle(&native_context_)) {
4848    native_context_ = Handle<Context>();
4849  }
4850
4851  if (!native_context().is_null()) {
4852    AddToWeakNativeContextList(*native_context());
4853    isolate->set_context(*native_context());
4854    isolate->counters()->contexts_created_by_snapshot()->Increment();
4855#if TRACE_MAPS
4856    if (FLAG_trace_maps) {
4857      Handle<JSFunction> object_fun = isolate->object_function();
4858      PrintF("[TraceMap: InitialMap map= %p SFI= %d_Object ]\n",
4859             reinterpret_cast<void*>(object_fun->initial_map()),
4860             object_fun->shared()->unique_id());
4861      Map::TraceAllTransitions(object_fun->initial_map());
4862    }
4863#endif
4864
4865    if (context_snapshot_index == 0) {
4866      Handle<JSGlobalObject> global_object =
4867          CreateNewGlobals(global_proxy_template, global_proxy);
4868      HookUpGlobalObject(global_object);
4869
4870      if (!ConfigureGlobalObjects(global_proxy_template)) return;
4871    } else {
4872      // The global proxy needs to be integrated into the native context.
4873      HookUpGlobalProxy(global_proxy);
4874    }
4875    DCHECK(!global_proxy->IsDetachedFrom(native_context()->global_object()));
4876  } else {
4877    DCHECK_EQ(0u, context_snapshot_index);
4878    // We get here if there was no context snapshot.
4879    CreateRoots();
4880    Handle<JSFunction> empty_function = CreateEmptyFunction(isolate);
4881    CreateStrictModeFunctionMaps(empty_function);
4882    CreateIteratorMaps(empty_function);
4883    CreateAsyncIteratorMaps();
4884    CreateAsyncFunctionMaps(empty_function);
4885    Handle<JSGlobalObject> global_object =
4886        CreateNewGlobals(global_proxy_template, global_proxy);
4887    InitializeGlobal(global_object, empty_function, context_type);
4888    InitializeNormalizedMapCaches();
4889
4890    if (!InstallNatives(context_type)) return;
4891
4892    MakeFunctionInstancePrototypeWritable();
4893
4894    if (!InstallExtraNatives()) return;
4895    if (!ConfigureGlobalObjects(global_proxy_template)) return;
4896
4897    isolate->counters()->contexts_created_from_scratch()->Increment();
4898  }
4899
4900  // Install experimental natives. Do not include them into the
4901  // snapshot as we should be able to turn them off at runtime. Re-installing
4902  // them after they have already been deserialized would also fail.
4903  if (context_type == FULL_CONTEXT) {
4904    if (!isolate->serializer_enabled()) {
4905      InitializeExperimentalGlobal();
4906      if (!InstallExperimentalNatives()) return;
4907
4908      if (FLAG_experimental_extras) {
4909        if (!InstallExperimentalExtraNatives()) return;
4910      }
4911
4912      // Store String.prototype's map again in case it has been changed by
4913      // experimental natives.
4914      Handle<JSFunction> string_function(native_context()->string_function());
4915      JSObject* string_function_prototype =
4916          JSObject::cast(string_function->initial_map()->prototype());
4917      DCHECK(string_function_prototype->HasFastProperties());
4918      native_context()->set_string_function_prototype_map(
4919          string_function_prototype->map());
4920    }
4921    // The serializer cannot serialize typed arrays. Reset those typed arrays
4922    // for each new context.
4923  } else if (context_type == DEBUG_CONTEXT) {
4924    DCHECK(!isolate->serializer_enabled());
4925    InitializeExperimentalGlobal();
4926    if (!InstallDebuggerNatives()) return;
4927  }
4928
4929  ConfigureUtilsObject(context_type);
4930
4931  // Check that the script context table is empty except for the 'this' binding.
4932  // We do not need script contexts for native scripts.
4933  DCHECK_EQ(1, native_context()->script_context_table()->used());
4934
4935  native_context()->ResetErrorsThrown();
4936  result_ = native_context();
4937}
4938
4939Genesis::Genesis(Isolate* isolate,
4940                 MaybeHandle<JSGlobalProxy> maybe_global_proxy,
4941                 v8::Local<v8::ObjectTemplate> global_proxy_template)
4942    : isolate_(isolate), active_(isolate->bootstrapper()) {
4943  NoTrackDoubleFieldsForSerializerScope disable_scope(isolate);
4944  result_ = Handle<Context>::null();
4945  global_proxy_ = Handle<JSGlobalProxy>::null();
4946
4947  // Before creating the roots we must save the context and restore it
4948  // on all function exits.
4949  SaveContext saved_context(isolate);
4950
4951  // During genesis, the boilerplate for stack overflow won't work until the
4952  // environment has been at least partially initialized. Add a stack check
4953  // before entering JS code to catch overflow early.
4954  StackLimitCheck check(isolate);
4955  if (check.HasOverflowed()) {
4956    isolate->StackOverflow();
4957    return;
4958  }
4959
4960  const int proxy_size = JSGlobalProxy::SizeWithInternalFields(
4961      global_proxy_template->InternalFieldCount());
4962
4963  Handle<JSGlobalProxy> global_proxy;
4964  if (!maybe_global_proxy.ToHandle(&global_proxy)) {
4965    global_proxy = factory()->NewUninitializedJSGlobalProxy(proxy_size);
4966  }
4967
4968  // Create a remote object as the global object.
4969  Handle<ObjectTemplateInfo> global_proxy_data =
4970      Utils::OpenHandle(*global_proxy_template);
4971  Handle<FunctionTemplateInfo> global_constructor(
4972      FunctionTemplateInfo::cast(global_proxy_data->constructor()));
4973
4974  Handle<ObjectTemplateInfo> global_object_template(
4975      ObjectTemplateInfo::cast(global_constructor->prototype_template()));
4976  Handle<JSObject> global_object =
4977      ApiNatives::InstantiateRemoteObject(
4978          global_object_template).ToHandleChecked();
4979
4980  // (Re)initialize the global proxy object.
4981  Handle<SharedFunctionInfo> shared =
4982      FunctionTemplateInfo::GetOrCreateSharedFunctionInfo(isolate,
4983                                                          global_constructor);
4984  Handle<Map> initial_map =
4985      factory()->CreateSloppyFunctionMap(FUNCTION_WITH_WRITEABLE_PROTOTYPE);
4986  Handle<JSFunction> global_proxy_function =
4987      isolate->factory()->NewFunctionFromSharedFunctionInfo(
4988          initial_map, shared, factory()->undefined_value());
4989  DCHECK_EQ(global_proxy_data->internal_field_count(),
4990            global_proxy_template->InternalFieldCount());
4991  Handle<Map> global_proxy_map = isolate->factory()->NewMap(
4992      JS_GLOBAL_PROXY_TYPE, proxy_size, FAST_HOLEY_SMI_ELEMENTS);
4993  JSFunction::SetInitialMap(global_proxy_function, global_proxy_map,
4994                            factory()->null_value());
4995  global_proxy_map->set_is_access_check_needed(true);
4996  global_proxy_map->set_has_hidden_prototype(true);
4997
4998  Handle<String> global_name = factory()->global_string();
4999  global_proxy_function->shared()->set_instance_class_name(*global_name);
5000  factory()->ReinitializeJSGlobalProxy(global_proxy, global_proxy_function);
5001
5002  // A remote global proxy has no native context.
5003  global_proxy->set_native_context(heap()->null_value());
5004
5005  // Configure the hidden prototype chain of the global proxy.
5006  JSObject::ForceSetPrototype(global_proxy, global_object);
5007  // TODO(dcheng): This is a hack. Why does this need to be manually called
5008  // here? Line 4812 should have taken care of it?
5009  global_proxy->map()->set_has_hidden_prototype(true);
5010
5011  global_proxy_ = global_proxy;
5012}
5013
5014// Support for thread preemption.
5015
5016// Reserve space for statics needing saving and restoring.
5017int Bootstrapper::ArchiveSpacePerThread() {
5018  return sizeof(NestingCounterType);
5019}
5020
5021
5022// Archive statics that are thread-local.
5023char* Bootstrapper::ArchiveState(char* to) {
5024  *reinterpret_cast<NestingCounterType*>(to) = nesting_;
5025  nesting_ = 0;
5026  return to + sizeof(NestingCounterType);
5027}
5028
5029
5030// Restore statics that are thread-local.
5031char* Bootstrapper::RestoreState(char* from) {
5032  nesting_ = *reinterpret_cast<NestingCounterType*>(from);
5033  return from + sizeof(NestingCounterType);
5034}
5035
5036
5037// Called when the top-level V8 mutex is destroyed.
5038void Bootstrapper::FreeThreadResources() {
5039  DCHECK(!IsActive());
5040}
5041
5042}  // namespace internal
5043}  // namespace v8
5044