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(Smi::FromInt(type_));
56   }
57 
58  private:
59   Script::Type type_;
60   FixedArray* cache_;
61   DISALLOW_COPY_AND_ASSIGN(SourceCodeCache);
62 };
63 
64 
65 // The Boostrapper is the public interface for creating a JavaScript global
66 // context.
67 class Bootstrapper FINAL {
68  public:
69   static void InitializeOncePerProcess();
70   static void TearDownExtensions();
71 
72   // Requires: Heap::SetUp has been called.
73   void Initialize(bool create_heap_objects);
74   void TearDown();
75 
76   // Creates a JavaScript Global Context with initial object graph.
77   // The returned value is a global handle casted to V8Environment*.
78   Handle<Context> CreateEnvironment(
79       MaybeHandle<JSGlobalProxy> maybe_global_proxy,
80       v8::Handle<v8::ObjectTemplate> global_object_template,
81       v8::ExtensionConfiguration* extensions);
82 
83   // Detach the environment from its outer global object.
84   void DetachGlobal(Handle<Context> env);
85 
86   // Traverses the pointers for memory management.
87   void Iterate(ObjectVisitor* v);
88 
89   // Accessor for the native scripts source code.
90   Handle<String> NativesSourceLookup(int index);
91 
92   // Tells whether bootstrapping is active.
IsActive()93   bool IsActive() const { return nesting_ != 0; }
94 
95   // Support for thread preemption.
96   static int ArchiveSpacePerThread();
97   char* ArchiveState(char* to);
98   char* RestoreState(char* from);
99   void FreeThreadResources();
100 
101   // This will allocate a char array that is deleted when V8 is shut down.
102   // It should only be used for strictly finite allocations.
103   char* AllocateAutoDeletedArray(int bytes);
104 
105   // Used for new context creation.
106   bool InstallExtensions(Handle<Context> native_context,
107                          v8::ExtensionConfiguration* extensions);
108 
extensions_cache()109   SourceCodeCache* extensions_cache() { return &extensions_cache_; }
110 
111  private:
112   Isolate* isolate_;
113   typedef int NestingCounterType;
114   NestingCounterType nesting_;
115   SourceCodeCache extensions_cache_;
116   // This is for delete, not delete[].
117   List<char*>* delete_these_non_arrays_on_tear_down_;
118   // This is for delete[]
119   List<char*>* delete_these_arrays_on_tear_down_;
120 
121   friend class BootstrapperActive;
122   friend class Isolate;
123   friend class NativesExternalStringResource;
124 
125   explicit Bootstrapper(Isolate* isolate);
126 
127   static v8::Extension* free_buffer_extension_;
128   static v8::Extension* gc_extension_;
129   static v8::Extension* externalize_string_extension_;
130   static v8::Extension* statistics_extension_;
131   static v8::Extension* trigger_failure_extension_;
132 
133   DISALLOW_COPY_AND_ASSIGN(Bootstrapper);
134 };
135 
136 
137 class BootstrapperActive FINAL BASE_EMBEDDED {
138  public:
BootstrapperActive(Bootstrapper * bootstrapper)139   explicit BootstrapperActive(Bootstrapper* bootstrapper)
140       : bootstrapper_(bootstrapper) {
141     ++bootstrapper_->nesting_;
142   }
143 
~BootstrapperActive()144   ~BootstrapperActive() {
145     --bootstrapper_->nesting_;
146   }
147 
148  private:
149   Bootstrapper* bootstrapper_;
150 
151   DISALLOW_COPY_AND_ASSIGN(BootstrapperActive);
152 };
153 
154 
155 class NativesExternalStringResource FINAL
156     : public v8::String::ExternalOneByteStringResource {
157  public:
158   NativesExternalStringResource(Bootstrapper* bootstrapper,
159                                 const char* source,
160                                 size_t length);
data()161   virtual const char* data() const OVERRIDE { return data_; }
length()162   virtual size_t length() const OVERRIDE { return length_; }
163 
164  private:
165   const char* data_;
166   size_t length_;
167 };
168 
169 }}  // namespace v8::internal
170 
171 #endif  // V8_BOOTSTRAPPER_H_
172