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 #ifndef V8_BOOTSTRAPPER_H_
6 #define V8_BOOTSTRAPPER_H_
7 
8 #include "src/factory.h"
9 
10 namespace v8 {
11 namespace internal {
12 
13 // A SourceCodeCache uses a FixedArray to store pairs of
14 // (OneByteString*, JSFunction*), mapping names of native code files
15 // (runtime.js, etc.) to precompiled functions. Instead of mapping
16 // names to functions it might make sense to let the JS2C tool
17 // generate an index for each native JS file.
18 class SourceCodeCache final BASE_EMBEDDED {
19  public:
SourceCodeCache(Script::Type type)20   explicit SourceCodeCache(Script::Type type): type_(type), cache_(NULL) { }
21 
Initialize(Isolate * isolate,bool create_heap_objects)22   void Initialize(Isolate* isolate, bool create_heap_objects) {
23     cache_ = create_heap_objects ? isolate->heap()->empty_fixed_array() : NULL;
24   }
25 
Iterate(ObjectVisitor * v)26   void Iterate(ObjectVisitor* v) {
27     v->VisitPointer(bit_cast<Object**, FixedArray**>(&cache_));
28   }
29 
Lookup(Vector<const char> name,Handle<SharedFunctionInfo> * handle)30   bool Lookup(Vector<const char> name, Handle<SharedFunctionInfo>* handle) {
31     for (int i = 0; i < cache_->length(); i+=2) {
32       SeqOneByteString* str = SeqOneByteString::cast(cache_->get(i));
33       if (str->IsUtf8EqualTo(name)) {
34         *handle = Handle<SharedFunctionInfo>(
35             SharedFunctionInfo::cast(cache_->get(i + 1)));
36         return true;
37       }
38     }
39     return false;
40   }
41 
Add(Vector<const char> name,Handle<SharedFunctionInfo> shared)42   void Add(Vector<const char> name, Handle<SharedFunctionInfo> shared) {
43     Isolate* isolate = shared->GetIsolate();
44     Factory* factory = isolate->factory();
45     HandleScope scope(isolate);
46     int length = cache_->length();
47     Handle<FixedArray> new_array = factory->NewFixedArray(length + 2, TENURED);
48     cache_->CopyTo(0, *new_array, 0, cache_->length());
49     cache_ = *new_array;
50     Handle<String> str =
51         factory->NewStringFromAscii(name, TENURED).ToHandleChecked();
52     DCHECK(!str.is_null());
53     cache_->set(length, *str);
54     cache_->set(length + 1, *shared);
55     Script::cast(shared->script())->set_type(type_);
56   }
57 
58  private:
59   Script::Type type_;
60   FixedArray* cache_;
61   DISALLOW_COPY_AND_ASSIGN(SourceCodeCache);
62 };
63 
64 enum ContextType { FULL_CONTEXT, THIN_CONTEXT, DEBUG_CONTEXT };
65 
66 // The Boostrapper is the public interface for creating a JavaScript global
67 // context.
68 class Bootstrapper final {
69  public:
70   static void InitializeOncePerProcess();
71   static void TearDownExtensions();
72 
73   // Requires: Heap::SetUp has been called.
74   void Initialize(bool create_heap_objects);
75   void TearDown();
76 
77   // Creates a JavaScript Global Context with initial object graph.
78   // The returned value is a global handle casted to V8Environment*.
79   Handle<Context> CreateEnvironment(
80       MaybeHandle<JSGlobalProxy> maybe_global_proxy,
81       v8::Local<v8::ObjectTemplate> global_object_template,
82       v8::ExtensionConfiguration* extensions,
83       ContextType context_type = FULL_CONTEXT);
84 
85   // Detach the environment from its outer global object.
86   void DetachGlobal(Handle<Context> env);
87 
88   // Traverses the pointers for memory management.
89   void Iterate(ObjectVisitor* v);
90 
91   // Accessor for the native scripts source code.
92   template <class Source>
93   Handle<String> SourceLookup(int index);
94 
95   // Tells whether bootstrapping is active.
IsActive()96   bool IsActive() const { return nesting_ != 0; }
97 
98   // Support for thread preemption.
99   static int ArchiveSpacePerThread();
100   char* ArchiveState(char* to);
101   char* RestoreState(char* from);
102   void FreeThreadResources();
103 
104   // Used for new context creation.
105   bool InstallExtensions(Handle<Context> native_context,
106                          v8::ExtensionConfiguration* extensions);
107 
extensions_cache()108   SourceCodeCache* extensions_cache() { return &extensions_cache_; }
109 
110   static bool CompileNative(Isolate* isolate, Vector<const char> name,
111                             Handle<String> source, int argc,
112                             Handle<Object> argv[]);
113   static bool CompileBuiltin(Isolate* isolate, int index);
114   static bool CompileExperimentalBuiltin(Isolate* isolate, int index);
115   static bool CompileExtraBuiltin(Isolate* isolate, int index);
116   static bool CompileExperimentalExtraBuiltin(Isolate* isolate, int index);
117 
118   static void ExportFromRuntime(Isolate* isolate, Handle<JSObject> container);
119   static void ExportExperimentalFromRuntime(Isolate* isolate,
120                                             Handle<JSObject> container);
121 
122  private:
123   Isolate* isolate_;
124   typedef int NestingCounterType;
125   NestingCounterType nesting_;
126   SourceCodeCache extensions_cache_;
127 
128   friend class BootstrapperActive;
129   friend class Isolate;
130   friend class NativesExternalStringResource;
131 
132   explicit Bootstrapper(Isolate* isolate);
133 
134   static v8::Extension* free_buffer_extension_;
135   static v8::Extension* gc_extension_;
136   static v8::Extension* externalize_string_extension_;
137   static v8::Extension* statistics_extension_;
138   static v8::Extension* trigger_failure_extension_;
139 
140   DISALLOW_COPY_AND_ASSIGN(Bootstrapper);
141 };
142 
143 
144 class BootstrapperActive final BASE_EMBEDDED {
145  public:
BootstrapperActive(Bootstrapper * bootstrapper)146   explicit BootstrapperActive(Bootstrapper* bootstrapper)
147       : bootstrapper_(bootstrapper) {
148     ++bootstrapper_->nesting_;
149   }
150 
~BootstrapperActive()151   ~BootstrapperActive() {
152     --bootstrapper_->nesting_;
153   }
154 
155  private:
156   Bootstrapper* bootstrapper_;
157 
158   DISALLOW_COPY_AND_ASSIGN(BootstrapperActive);
159 };
160 
161 
162 class NativesExternalStringResource final
163     : public v8::String::ExternalOneByteStringResource {
164  public:
NativesExternalStringResource(const char * source,size_t length)165   NativesExternalStringResource(const char* source, size_t length)
166       : data_(source), length_(length) {}
data()167   const char* data() const override { return data_; }
length()168   size_t length() const override { return length_; }
169 
170  private:
171   const char* data_;
172   size_t length_;
173 };
174 
175 }  // namespace internal
176 }  // namespace v8
177 
178 #endif  // V8_BOOTSTRAPPER_H_
179