Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 1 | // Copyright 2012 the V8 project authors. All rights reserved. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 4 | |
| 5 | #ifndef V8_COMPILER_H_ |
| 6 | #define V8_COMPILER_H_ |
| 7 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 8 | #include "src/allocation.h" |
| 9 | #include "src/ast.h" |
| 10 | #include "src/bailout-reason.h" |
| 11 | #include "src/zone.h" |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 12 | |
| 13 | namespace v8 { |
| 14 | namespace internal { |
| 15 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 16 | class AstValueFactory; |
| 17 | class HydrogenCodeStub; |
| 18 | |
| 19 | // ParseRestriction is used to restrict the set of valid statements in a |
| 20 | // unit of compilation. Restriction violations cause a syntax error. |
| 21 | enum ParseRestriction { |
| 22 | NO_PARSE_RESTRICTION, // All expressions are allowed. |
| 23 | ONLY_SINGLE_FUNCTION_LITERAL // Only a single FunctionLiteral expression. |
| 24 | }; |
| 25 | |
| 26 | struct OffsetRange { |
| 27 | OffsetRange(int from, int to) : from(from), to(to) {} |
| 28 | int from; |
| 29 | int to; |
| 30 | }; |
| 31 | |
| 32 | |
| 33 | class ScriptData { |
| 34 | public: |
| 35 | ScriptData(const byte* data, int length); |
| 36 | ~ScriptData() { |
| 37 | if (owns_data_) DeleteArray(data_); |
| 38 | } |
| 39 | |
| 40 | const byte* data() const { return data_; } |
| 41 | int length() const { return length_; } |
| 42 | |
| 43 | void AcquireDataOwnership() { |
| 44 | DCHECK(!owns_data_); |
| 45 | owns_data_ = true; |
| 46 | } |
| 47 | |
| 48 | void ReleaseDataOwnership() { |
| 49 | DCHECK(owns_data_); |
| 50 | owns_data_ = false; |
| 51 | } |
| 52 | |
| 53 | private: |
| 54 | bool owns_data_; |
| 55 | const byte* data_; |
| 56 | int length_; |
| 57 | |
| 58 | DISALLOW_COPY_AND_ASSIGN(ScriptData); |
| 59 | }; |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 60 | |
Andrei Popescu | 3100271 | 2010-02-23 13:46:05 +0000 | [diff] [blame] | 61 | // CompilationInfo encapsulates some information known at compile time. It |
| 62 | // is constructed based on the resources available at compile-time. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 63 | class CompilationInfo { |
Leon Clarke | 4515c47 | 2010-02-03 11:58:03 +0000 | [diff] [blame] | 64 | public: |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 65 | // Various configuration flags for a compilation, as well as some properties |
| 66 | // of the compiled code produced by a compilation. |
| 67 | enum Flag { |
| 68 | kLazy = 1 << 0, |
| 69 | kEval = 1 << 1, |
| 70 | kGlobal = 1 << 2, |
| 71 | kStrictMode = 1 << 3, |
| 72 | kThisHasUses = 1 << 4, |
| 73 | kNative = 1 << 5, |
| 74 | kDeferredCalling = 1 << 6, |
| 75 | kNonDeferredCalling = 1 << 7, |
| 76 | kSavesCallerDoubles = 1 << 8, |
| 77 | kRequiresFrame = 1 << 9, |
| 78 | kMustNotHaveEagerFrame = 1 << 10, |
| 79 | kDeoptimizationSupport = 1 << 11, |
| 80 | kDebug = 1 << 12, |
| 81 | kCompilingForDebugging = 1 << 13, |
| 82 | kParseRestriction = 1 << 14, |
| 83 | kSerializing = 1 << 15, |
| 84 | kContextSpecializing = 1 << 16, |
| 85 | kInliningEnabled = 1 << 17, |
| 86 | kTypingEnabled = 1 << 18, |
| 87 | kDisableFutureOptimization = 1 << 19 |
| 88 | }; |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 89 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 90 | CompilationInfo(Handle<JSFunction> closure, Zone* zone); |
| 91 | CompilationInfo(Isolate* isolate, Zone* zone); |
| 92 | virtual ~CompilationInfo(); |
| 93 | |
| 94 | Isolate* isolate() const { |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 95 | return isolate_; |
| 96 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 97 | Zone* zone() { return zone_; } |
| 98 | bool is_osr() const { return !osr_ast_id_.IsNone(); } |
| 99 | bool is_lazy() const { return GetFlag(kLazy); } |
| 100 | bool is_eval() const { return GetFlag(kEval); } |
| 101 | bool is_global() const { return GetFlag(kGlobal); } |
| 102 | StrictMode strict_mode() const { |
| 103 | return GetFlag(kStrictMode) ? STRICT : SLOPPY; |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 104 | } |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 105 | FunctionLiteral* function() const { return function_; } |
| 106 | Scope* scope() const { return scope_; } |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 107 | Scope* global_scope() const { return global_scope_; } |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 108 | Handle<Code> code() const { return code_; } |
| 109 | Handle<JSFunction> closure() const { return closure_; } |
| 110 | Handle<SharedFunctionInfo> shared_info() const { return shared_info_; } |
| 111 | Handle<Script> script() const { return script_; } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 112 | void set_script(Handle<Script> script) { script_ = script; } |
| 113 | HydrogenCodeStub* code_stub() const {return code_stub_; } |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 114 | v8::Extension* extension() const { return extension_; } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 115 | ScriptData** cached_data() const { return cached_data_; } |
| 116 | ScriptCompiler::CompileOptions compile_options() const { |
| 117 | return compile_options_; |
| 118 | } |
| 119 | ScriptCompiler::ExternalSourceStream* source_stream() const { |
| 120 | return source_stream_; |
| 121 | } |
| 122 | ScriptCompiler::StreamedSource::Encoding source_stream_encoding() const { |
| 123 | return source_stream_encoding_; |
| 124 | } |
| 125 | Handle<Context> context() const { return context_; } |
| 126 | BailoutId osr_ast_id() const { return osr_ast_id_; } |
| 127 | Handle<Code> unoptimized_code() const { return unoptimized_code_; } |
| 128 | int opt_count() const { return opt_count_; } |
| 129 | int num_parameters() const; |
| 130 | int num_heap_slots() const; |
| 131 | Code::Flags flags() const; |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 132 | |
| 133 | void MarkAsEval() { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 134 | DCHECK(!is_lazy()); |
| 135 | SetFlag(kEval); |
Leon Clarke | 4515c47 | 2010-02-03 11:58:03 +0000 | [diff] [blame] | 136 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 137 | |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 138 | void MarkAsGlobal() { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 139 | DCHECK(!is_lazy()); |
| 140 | SetFlag(kGlobal); |
Andrei Popescu | 3100271 | 2010-02-23 13:46:05 +0000 | [diff] [blame] | 141 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 142 | |
| 143 | void set_parameter_count(int parameter_count) { |
| 144 | DCHECK(IsStub()); |
| 145 | parameter_count_ = parameter_count; |
Steve Block | 1e0659c | 2011-05-24 12:43:12 +0100 | [diff] [blame] | 146 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 147 | |
| 148 | void set_this_has_uses(bool has_no_uses) { |
| 149 | SetFlag(kThisHasUses, has_no_uses); |
Andrei Popescu | 3100271 | 2010-02-23 13:46:05 +0000 | [diff] [blame] | 150 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 151 | |
| 152 | bool this_has_uses() { return GetFlag(kThisHasUses); } |
| 153 | |
| 154 | void SetStrictMode(StrictMode strict_mode) { |
| 155 | SetFlag(kStrictMode, strict_mode == STRICT); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 156 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 157 | |
| 158 | void MarkAsNative() { SetFlag(kNative); } |
| 159 | |
| 160 | bool is_native() const { return GetFlag(kNative); } |
| 161 | |
| 162 | bool is_calling() const { |
| 163 | return GetFlag(kDeferredCalling) || GetFlag(kNonDeferredCalling); |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 164 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 165 | |
| 166 | void MarkAsDeferredCalling() { SetFlag(kDeferredCalling); } |
| 167 | |
| 168 | bool is_deferred_calling() const { return GetFlag(kDeferredCalling); } |
| 169 | |
| 170 | void MarkAsNonDeferredCalling() { SetFlag(kNonDeferredCalling); } |
| 171 | |
| 172 | bool is_non_deferred_calling() const { return GetFlag(kNonDeferredCalling); } |
| 173 | |
| 174 | void MarkAsSavesCallerDoubles() { SetFlag(kSavesCallerDoubles); } |
| 175 | |
| 176 | bool saves_caller_doubles() const { return GetFlag(kSavesCallerDoubles); } |
| 177 | |
| 178 | void MarkAsRequiresFrame() { SetFlag(kRequiresFrame); } |
| 179 | |
| 180 | bool requires_frame() const { return GetFlag(kRequiresFrame); } |
| 181 | |
| 182 | void MarkMustNotHaveEagerFrame() { SetFlag(kMustNotHaveEagerFrame); } |
| 183 | |
| 184 | bool GetMustNotHaveEagerFrame() const { |
| 185 | return GetFlag(kMustNotHaveEagerFrame); |
| 186 | } |
| 187 | |
| 188 | void MarkAsDebug() { SetFlag(kDebug); } |
| 189 | |
| 190 | bool is_debug() const { return GetFlag(kDebug); } |
| 191 | |
| 192 | void PrepareForSerializing() { SetFlag(kSerializing); } |
| 193 | |
| 194 | bool will_serialize() const { return GetFlag(kSerializing); } |
| 195 | |
| 196 | void MarkAsContextSpecializing() { SetFlag(kContextSpecializing); } |
| 197 | |
| 198 | bool is_context_specializing() const { return GetFlag(kContextSpecializing); } |
| 199 | |
| 200 | void MarkAsInliningEnabled() { SetFlag(kInliningEnabled); } |
| 201 | |
| 202 | void MarkAsInliningDisabled() { SetFlag(kInliningEnabled, false); } |
| 203 | |
| 204 | bool is_inlining_enabled() const { return GetFlag(kInliningEnabled); } |
| 205 | |
| 206 | void MarkAsTypingEnabled() { SetFlag(kTypingEnabled); } |
| 207 | |
| 208 | bool is_typing_enabled() const { return GetFlag(kTypingEnabled); } |
| 209 | |
| 210 | bool IsCodePreAgingActive() const { |
| 211 | return FLAG_optimize_for_size && FLAG_age_code && !will_serialize() && |
| 212 | !is_debug(); |
| 213 | } |
| 214 | |
| 215 | void SetParseRestriction(ParseRestriction restriction) { |
| 216 | SetFlag(kParseRestriction, restriction != NO_PARSE_RESTRICTION); |
| 217 | } |
| 218 | |
| 219 | ParseRestriction parse_restriction() const { |
| 220 | return GetFlag(kParseRestriction) ? ONLY_SINGLE_FUNCTION_LITERAL |
| 221 | : NO_PARSE_RESTRICTION; |
| 222 | } |
| 223 | |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 224 | void SetFunction(FunctionLiteral* literal) { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 225 | DCHECK(function_ == NULL); |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 226 | function_ = literal; |
Andrei Popescu | 3100271 | 2010-02-23 13:46:05 +0000 | [diff] [blame] | 227 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 228 | void PrepareForCompilation(Scope* scope); |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 229 | void SetGlobalScope(Scope* global_scope) { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 230 | DCHECK(global_scope_ == NULL); |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 231 | global_scope_ = global_scope; |
| 232 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 233 | Handle<TypeFeedbackVector> feedback_vector() const { |
| 234 | return feedback_vector_; |
| 235 | } |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 236 | void SetCode(Handle<Code> code) { code_ = code; } |
| 237 | void SetExtension(v8::Extension* extension) { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 238 | DCHECK(!is_lazy()); |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 239 | extension_ = extension; |
Andrei Popescu | 3100271 | 2010-02-23 13:46:05 +0000 | [diff] [blame] | 240 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 241 | void SetCachedData(ScriptData** cached_data, |
| 242 | ScriptCompiler::CompileOptions compile_options) { |
| 243 | compile_options_ = compile_options; |
| 244 | if (compile_options == ScriptCompiler::kNoCompileOptions) { |
| 245 | cached_data_ = NULL; |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 246 | } else { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 247 | DCHECK(!is_lazy()); |
| 248 | cached_data_ = cached_data; |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 249 | } |
| 250 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 251 | void SetContext(Handle<Context> context) { |
| 252 | context_ = context; |
| 253 | } |
| 254 | |
| 255 | void MarkCompilingForDebugging() { SetFlag(kCompilingForDebugging); } |
| 256 | bool IsCompilingForDebugging() { return GetFlag(kCompilingForDebugging); } |
| 257 | void MarkNonOptimizable() { |
| 258 | SetMode(CompilationInfo::NONOPT); |
| 259 | } |
| 260 | |
| 261 | bool ShouldTrapOnDeopt() const { |
| 262 | return (FLAG_trap_on_deopt && IsOptimizing()) || |
| 263 | (FLAG_trap_on_stub_deopt && IsStub()); |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 264 | } |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 265 | |
| 266 | bool has_global_object() const { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 267 | return !closure().is_null() && |
| 268 | (closure()->context()->global_object() != NULL); |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 269 | } |
| 270 | |
| 271 | GlobalObject* global_object() const { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 272 | return has_global_object() ? closure()->context()->global_object() : NULL; |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 273 | } |
| 274 | |
| 275 | // Accessors for the different compilation modes. |
| 276 | bool IsOptimizing() const { return mode_ == OPTIMIZE; } |
| 277 | bool IsOptimizable() const { return mode_ == BASE; } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 278 | bool IsStub() const { return mode_ == STUB; } |
| 279 | void SetOptimizing(BailoutId osr_ast_id, Handle<Code> unoptimized) { |
| 280 | DCHECK(!shared_info_.is_null()); |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 281 | SetMode(OPTIMIZE); |
| 282 | osr_ast_id_ = osr_ast_id; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 283 | unoptimized_code_ = unoptimized; |
| 284 | optimization_id_ = isolate()->NextOptimizationId(); |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 285 | } |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 286 | |
| 287 | // Deoptimization support. |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 288 | bool HasDeoptimizationSupport() const { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 289 | return GetFlag(kDeoptimizationSupport); |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 290 | } |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 291 | void EnableDeoptimizationSupport() { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 292 | DCHECK(IsOptimizable()); |
| 293 | SetFlag(kDeoptimizationSupport); |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 294 | } |
| 295 | |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 296 | // Determines whether or not to insert a self-optimization header. |
| 297 | bool ShouldSelfOptimize(); |
Andrei Popescu | 3100271 | 2010-02-23 13:46:05 +0000 | [diff] [blame] | 298 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 299 | void set_deferred_handles(DeferredHandles* deferred_handles) { |
| 300 | DCHECK(deferred_handles_ == NULL); |
| 301 | deferred_handles_ = deferred_handles; |
| 302 | } |
| 303 | |
| 304 | ZoneList<Handle<HeapObject> >* dependencies( |
| 305 | DependentCode::DependencyGroup group) { |
| 306 | if (dependencies_[group] == NULL) { |
| 307 | dependencies_[group] = new(zone_) ZoneList<Handle<HeapObject> >(2, zone_); |
| 308 | } |
| 309 | return dependencies_[group]; |
| 310 | } |
| 311 | |
| 312 | void CommitDependencies(Handle<Code> code); |
| 313 | |
| 314 | void RollbackDependencies(); |
| 315 | |
| 316 | void SaveHandles() { |
| 317 | SaveHandle(&closure_); |
| 318 | SaveHandle(&shared_info_); |
| 319 | SaveHandle(&context_); |
| 320 | SaveHandle(&script_); |
| 321 | SaveHandle(&unoptimized_code_); |
| 322 | } |
| 323 | |
| 324 | void AbortOptimization(BailoutReason reason) { |
| 325 | if (bailout_reason_ != kNoReason) bailout_reason_ = reason; |
| 326 | SetFlag(kDisableFutureOptimization); |
| 327 | } |
| 328 | |
| 329 | void RetryOptimization(BailoutReason reason) { |
| 330 | if (bailout_reason_ != kNoReason) bailout_reason_ = reason; |
| 331 | } |
| 332 | |
| 333 | BailoutReason bailout_reason() const { return bailout_reason_; } |
| 334 | |
| 335 | int prologue_offset() const { |
| 336 | DCHECK_NE(Code::kPrologueOffsetNotSet, prologue_offset_); |
| 337 | return prologue_offset_; |
| 338 | } |
| 339 | |
| 340 | void set_prologue_offset(int prologue_offset) { |
| 341 | DCHECK_EQ(Code::kPrologueOffsetNotSet, prologue_offset_); |
| 342 | prologue_offset_ = prologue_offset; |
| 343 | } |
| 344 | |
| 345 | // Adds offset range [from, to) where fp register does not point |
| 346 | // to the current frame base. Used in CPU profiler to detect stack |
| 347 | // samples where top frame is not set up. |
| 348 | inline void AddNoFrameRange(int from, int to) { |
| 349 | if (no_frame_ranges_) no_frame_ranges_->Add(OffsetRange(from, to)); |
| 350 | } |
| 351 | |
| 352 | List<OffsetRange>* ReleaseNoFrameRanges() { |
| 353 | List<OffsetRange>* result = no_frame_ranges_; |
| 354 | no_frame_ranges_ = NULL; |
| 355 | return result; |
| 356 | } |
| 357 | |
| 358 | Handle<Foreign> object_wrapper() { |
| 359 | if (object_wrapper_.is_null()) { |
| 360 | object_wrapper_ = |
| 361 | isolate()->factory()->NewForeign(reinterpret_cast<Address>(this)); |
| 362 | } |
| 363 | return object_wrapper_; |
| 364 | } |
| 365 | |
| 366 | void AbortDueToDependencyChange() { |
| 367 | DCHECK(!OptimizingCompilerThread::IsOptimizerThread(isolate())); |
| 368 | aborted_due_to_dependency_change_ = true; |
| 369 | } |
| 370 | |
| 371 | bool HasAbortedDueToDependencyChange() const { |
| 372 | DCHECK(!OptimizingCompilerThread::IsOptimizerThread(isolate())); |
| 373 | return aborted_due_to_dependency_change_; |
| 374 | } |
| 375 | |
| 376 | bool HasSameOsrEntry(Handle<JSFunction> function, BailoutId osr_ast_id) { |
| 377 | return osr_ast_id_ == osr_ast_id && function.is_identical_to(closure_); |
| 378 | } |
| 379 | |
| 380 | int optimization_id() const { return optimization_id_; } |
| 381 | |
| 382 | AstValueFactory* ast_value_factory() const { return ast_value_factory_; } |
| 383 | void SetAstValueFactory(AstValueFactory* ast_value_factory, |
| 384 | bool owned = true) { |
| 385 | ast_value_factory_ = ast_value_factory; |
| 386 | ast_value_factory_owned_ = owned; |
| 387 | } |
| 388 | |
| 389 | AstNode::IdGen* ast_node_id_gen() { return &ast_node_id_gen_; } |
| 390 | |
| 391 | protected: |
| 392 | CompilationInfo(Handle<Script> script, |
| 393 | Zone* zone); |
| 394 | CompilationInfo(Handle<SharedFunctionInfo> shared_info, |
| 395 | Zone* zone); |
| 396 | CompilationInfo(HydrogenCodeStub* stub, |
| 397 | Isolate* isolate, |
| 398 | Zone* zone); |
| 399 | CompilationInfo(ScriptCompiler::ExternalSourceStream* source_stream, |
| 400 | ScriptCompiler::StreamedSource::Encoding encoding, |
| 401 | Isolate* isolate, Zone* zone); |
| 402 | |
Ben Murdoch | 257744e | 2011-11-30 15:57:28 +0000 | [diff] [blame] | 403 | |
Leon Clarke | 4515c47 | 2010-02-03 11:58:03 +0000 | [diff] [blame] | 404 | private: |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 405 | Isolate* isolate_; |
| 406 | |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 407 | // Compilation mode. |
| 408 | // BASE is generated by the full codegen, optionally prepared for bailouts. |
| 409 | // OPTIMIZE is optimized code generated by the Hydrogen-based backend. |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 410 | // NONOPT is generated by the full codegen and is not prepared for |
| 411 | // recompilation/bailouts. These functions are never recompiled. |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 412 | enum Mode { |
| 413 | BASE, |
| 414 | OPTIMIZE, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 415 | NONOPT, |
| 416 | STUB |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 417 | }; |
| 418 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 419 | void Initialize(Isolate* isolate, Mode mode, Zone* zone); |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 420 | |
| 421 | void SetMode(Mode mode) { |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 422 | mode_ = mode; |
| 423 | } |
| 424 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 425 | void SetFlag(Flag flag) { flags_ |= flag; } |
Andrei Popescu | 3100271 | 2010-02-23 13:46:05 +0000 | [diff] [blame] | 426 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 427 | void SetFlag(Flag flag, bool value) { |
| 428 | flags_ = value ? flags_ | flag : flags_ & ~flag; |
| 429 | } |
| 430 | |
| 431 | bool GetFlag(Flag flag) const { return (flags_ & flag) != 0; } |
Ben Murdoch | 3fb3ca8 | 2011-12-02 17:19:32 +0000 | [diff] [blame] | 432 | |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 433 | unsigned flags_; |
| 434 | |
| 435 | // Fields filled in by the compilation pipeline. |
| 436 | // AST filled in by the parser. |
| 437 | FunctionLiteral* function_; |
Teng-Hui Zhu | 3e5fa29 | 2010-11-09 16:16:48 -0800 | [diff] [blame] | 438 | // The scope of the function literal as a convenience. Set to indicate |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 439 | // that scopes have been analyzed. |
| 440 | Scope* scope_; |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 441 | // The global scope provided as a convenience. |
| 442 | Scope* global_scope_; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 443 | // For compiled stubs, the stub object |
| 444 | HydrogenCodeStub* code_stub_; |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 445 | // The compiled code. |
| 446 | Handle<Code> code_; |
| 447 | |
| 448 | // Possible initial inputs to the compilation process. |
Andrei Popescu | 3100271 | 2010-02-23 13:46:05 +0000 | [diff] [blame] | 449 | Handle<JSFunction> closure_; |
Leon Clarke | 4515c47 | 2010-02-03 11:58:03 +0000 | [diff] [blame] | 450 | Handle<SharedFunctionInfo> shared_info_; |
Andrei Popescu | 3100271 | 2010-02-23 13:46:05 +0000 | [diff] [blame] | 451 | Handle<Script> script_; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 452 | ScriptCompiler::ExternalSourceStream* source_stream_; // Not owned. |
| 453 | ScriptCompiler::StreamedSource::Encoding source_stream_encoding_; |
Andrei Popescu | 3100271 | 2010-02-23 13:46:05 +0000 | [diff] [blame] | 454 | |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 455 | // Fields possibly needed for eager compilation, NULL by default. |
| 456 | v8::Extension* extension_; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 457 | ScriptData** cached_data_; |
| 458 | ScriptCompiler::CompileOptions compile_options_; |
Andrei Popescu | 3100271 | 2010-02-23 13:46:05 +0000 | [diff] [blame] | 459 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 460 | // The context of the caller for eval code, and the global context for a |
| 461 | // global script. Will be a null handle otherwise. |
| 462 | Handle<Context> context_; |
| 463 | |
| 464 | // Used by codegen, ultimately kept rooted by the SharedFunctionInfo. |
| 465 | Handle<TypeFeedbackVector> feedback_vector_; |
Andrei Popescu | 3100271 | 2010-02-23 13:46:05 +0000 | [diff] [blame] | 466 | |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 467 | // Compilation mode flag and whether deoptimization is allowed. |
| 468 | Mode mode_; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 469 | BailoutId osr_ast_id_; |
| 470 | // The unoptimized code we patched for OSR may not be the shared code |
| 471 | // afterwards, since we may need to compile it again to include deoptimization |
| 472 | // data. Keep track which code we patched. |
| 473 | Handle<Code> unoptimized_code_; |
| 474 | |
| 475 | // The zone from which the compilation pipeline working on this |
| 476 | // CompilationInfo allocates. |
| 477 | Zone* zone_; |
| 478 | |
| 479 | DeferredHandles* deferred_handles_; |
| 480 | |
| 481 | ZoneList<Handle<HeapObject> >* dependencies_[DependentCode::kGroupCount]; |
| 482 | |
| 483 | template<typename T> |
| 484 | void SaveHandle(Handle<T> *object) { |
| 485 | if (!object->is_null()) { |
| 486 | Handle<T> handle(*(*object)); |
| 487 | *object = handle; |
| 488 | } |
| 489 | } |
| 490 | |
| 491 | BailoutReason bailout_reason_; |
| 492 | |
| 493 | int prologue_offset_; |
| 494 | |
| 495 | List<OffsetRange>* no_frame_ranges_; |
| 496 | |
| 497 | // A copy of shared_info()->opt_count() to avoid handle deref |
| 498 | // during graph optimization. |
| 499 | int opt_count_; |
| 500 | |
| 501 | // Number of parameters used for compilation of stubs that require arguments. |
| 502 | int parameter_count_; |
| 503 | |
| 504 | Handle<Foreign> object_wrapper_; |
| 505 | |
| 506 | int optimization_id_; |
| 507 | |
| 508 | AstValueFactory* ast_value_factory_; |
| 509 | bool ast_value_factory_owned_; |
| 510 | AstNode::IdGen ast_node_id_gen_; |
| 511 | |
| 512 | // This flag is used by the main thread to track whether this compilation |
| 513 | // should be abandoned due to dependency change. |
| 514 | bool aborted_due_to_dependency_change_; |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 515 | |
Andrei Popescu | 3100271 | 2010-02-23 13:46:05 +0000 | [diff] [blame] | 516 | DISALLOW_COPY_AND_ASSIGN(CompilationInfo); |
Leon Clarke | 4515c47 | 2010-02-03 11:58:03 +0000 | [diff] [blame] | 517 | }; |
| 518 | |
| 519 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 520 | // Exactly like a CompilationInfo, except also creates and enters a |
| 521 | // Zone on construction and deallocates it on exit. |
| 522 | class CompilationInfoWithZone: public CompilationInfo { |
| 523 | public: |
| 524 | explicit CompilationInfoWithZone(Handle<Script> script) |
| 525 | : CompilationInfo(script, &zone_), |
| 526 | zone_(script->GetIsolate()) {} |
| 527 | explicit CompilationInfoWithZone(Handle<SharedFunctionInfo> shared_info) |
| 528 | : CompilationInfo(shared_info, &zone_), |
| 529 | zone_(shared_info->GetIsolate()) {} |
| 530 | explicit CompilationInfoWithZone(Handle<JSFunction> closure) |
| 531 | : CompilationInfo(closure, &zone_), |
| 532 | zone_(closure->GetIsolate()) {} |
| 533 | CompilationInfoWithZone(HydrogenCodeStub* stub, Isolate* isolate) |
| 534 | : CompilationInfo(stub, isolate, &zone_), |
| 535 | zone_(isolate) {} |
| 536 | CompilationInfoWithZone(ScriptCompiler::ExternalSourceStream* stream, |
| 537 | ScriptCompiler::StreamedSource::Encoding encoding, |
| 538 | Isolate* isolate) |
| 539 | : CompilationInfo(stream, encoding, isolate, &zone_), zone_(isolate) {} |
| 540 | |
| 541 | // Virtual destructor because a CompilationInfoWithZone has to exit the |
| 542 | // zone scope and get rid of dependent maps even when the destructor is |
| 543 | // called when cast as a CompilationInfo. |
| 544 | virtual ~CompilationInfoWithZone() { |
| 545 | RollbackDependencies(); |
| 546 | } |
| 547 | |
| 548 | private: |
| 549 | Zone zone_; |
| 550 | }; |
| 551 | |
| 552 | |
| 553 | // A wrapper around a CompilationInfo that detaches the Handles from |
| 554 | // the underlying DeferredHandleScope and stores them in info_ on |
| 555 | // destruction. |
| 556 | class CompilationHandleScope BASE_EMBEDDED { |
| 557 | public: |
| 558 | explicit CompilationHandleScope(CompilationInfo* info) |
| 559 | : deferred_(info->isolate()), info_(info) {} |
| 560 | ~CompilationHandleScope() { |
| 561 | info_->set_deferred_handles(deferred_.Detach()); |
| 562 | } |
| 563 | |
| 564 | private: |
| 565 | DeferredHandleScope deferred_; |
| 566 | CompilationInfo* info_; |
| 567 | }; |
| 568 | |
| 569 | |
| 570 | class HGraph; |
| 571 | class HOptimizedGraphBuilder; |
| 572 | class LChunk; |
| 573 | |
| 574 | // A helper class that calls the three compilation phases in |
| 575 | // Crankshaft and keeps track of its state. The three phases |
| 576 | // CreateGraph, OptimizeGraph and GenerateAndInstallCode can either |
| 577 | // fail, bail-out to the full code generator or succeed. Apart from |
| 578 | // their return value, the status of the phase last run can be checked |
| 579 | // using last_status(). |
| 580 | class OptimizedCompileJob: public ZoneObject { |
| 581 | public: |
| 582 | explicit OptimizedCompileJob(CompilationInfo* info) |
| 583 | : info_(info), |
| 584 | graph_builder_(NULL), |
| 585 | graph_(NULL), |
| 586 | chunk_(NULL), |
| 587 | last_status_(FAILED), |
| 588 | awaiting_install_(false) { } |
| 589 | |
| 590 | enum Status { |
| 591 | FAILED, BAILED_OUT, SUCCEEDED |
| 592 | }; |
| 593 | |
| 594 | MUST_USE_RESULT Status CreateGraph(); |
| 595 | MUST_USE_RESULT Status OptimizeGraph(); |
| 596 | MUST_USE_RESULT Status GenerateCode(); |
| 597 | |
| 598 | Status last_status() const { return last_status_; } |
| 599 | CompilationInfo* info() const { return info_; } |
| 600 | Isolate* isolate() const { return info()->isolate(); } |
| 601 | |
| 602 | Status RetryOptimization(BailoutReason reason) { |
| 603 | info_->RetryOptimization(reason); |
| 604 | return SetLastStatus(BAILED_OUT); |
| 605 | } |
| 606 | |
| 607 | Status AbortOptimization(BailoutReason reason) { |
| 608 | info_->AbortOptimization(reason); |
| 609 | return SetLastStatus(BAILED_OUT); |
| 610 | } |
| 611 | |
| 612 | void WaitForInstall() { |
| 613 | DCHECK(info_->is_osr()); |
| 614 | awaiting_install_ = true; |
| 615 | } |
| 616 | |
| 617 | bool IsWaitingForInstall() { return awaiting_install_; } |
| 618 | |
| 619 | private: |
| 620 | CompilationInfo* info_; |
| 621 | HOptimizedGraphBuilder* graph_builder_; |
| 622 | HGraph* graph_; |
| 623 | LChunk* chunk_; |
| 624 | base::TimeDelta time_taken_to_create_graph_; |
| 625 | base::TimeDelta time_taken_to_optimize_; |
| 626 | base::TimeDelta time_taken_to_codegen_; |
| 627 | Status last_status_; |
| 628 | bool awaiting_install_; |
| 629 | |
| 630 | MUST_USE_RESULT Status SetLastStatus(Status status) { |
| 631 | last_status_ = status; |
| 632 | return last_status_; |
| 633 | } |
| 634 | void RecordOptimizationStats(); |
| 635 | |
| 636 | struct Timer { |
| 637 | Timer(OptimizedCompileJob* job, base::TimeDelta* location) |
| 638 | : job_(job), location_(location) { |
| 639 | DCHECK(location_ != NULL); |
| 640 | timer_.Start(); |
| 641 | } |
| 642 | |
| 643 | ~Timer() { |
| 644 | *location_ += timer_.Elapsed(); |
| 645 | } |
| 646 | |
| 647 | OptimizedCompileJob* job_; |
| 648 | base::ElapsedTimer timer_; |
| 649 | base::TimeDelta* location_; |
| 650 | }; |
| 651 | }; |
| 652 | |
| 653 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 654 | // The V8 compiler |
| 655 | // |
| 656 | // General strategy: Source code is translated into an anonymous function w/o |
| 657 | // parameters which then can be executed. If the source code contains other |
| 658 | // functions, they will be compiled and allocated as part of the compilation |
| 659 | // of the source code. |
| 660 | |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 661 | // Please note this interface returns shared function infos. This means you |
| 662 | // need to call Factory::NewFunctionFromSharedFunctionInfo before you have a |
| 663 | // real function with a context. |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 664 | |
| 665 | class Compiler : public AllStatic { |
| 666 | public: |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 667 | MUST_USE_RESULT static MaybeHandle<Code> GetUnoptimizedCode( |
| 668 | Handle<JSFunction> function); |
| 669 | MUST_USE_RESULT static MaybeHandle<Code> GetLazyCode( |
| 670 | Handle<JSFunction> function); |
| 671 | MUST_USE_RESULT static MaybeHandle<Code> GetUnoptimizedCode( |
| 672 | Handle<SharedFunctionInfo> shared); |
| 673 | MUST_USE_RESULT static MaybeHandle<Code> GetDebugCode( |
| 674 | Handle<JSFunction> function); |
Ben Murdoch | b8e0da2 | 2011-05-16 14:20:40 +0100 | [diff] [blame] | 675 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 676 | static bool EnsureCompiled(Handle<JSFunction> function, |
| 677 | ClearExceptionFlag flag); |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 678 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 679 | static bool EnsureDeoptimizationSupport(CompilationInfo* info); |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 680 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 681 | static void CompileForLiveEdit(Handle<Script> script); |
| 682 | |
| 683 | // Compile a String source within a context for eval. |
| 684 | MUST_USE_RESULT static MaybeHandle<JSFunction> GetFunctionFromEval( |
| 685 | Handle<String> source, Handle<SharedFunctionInfo> outer_info, |
| 686 | Handle<Context> context, StrictMode strict_mode, |
| 687 | ParseRestriction restriction, int scope_position); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 688 | |
| 689 | // Compile a String source within a context. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 690 | static Handle<SharedFunctionInfo> CompileScript( |
| 691 | Handle<String> source, Handle<Object> script_name, int line_offset, |
| 692 | int column_offset, bool is_shared_cross_origin, Handle<Context> context, |
| 693 | v8::Extension* extension, ScriptData** cached_data, |
| 694 | ScriptCompiler::CompileOptions compile_options, |
| 695 | NativesFlag is_natives_code); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 696 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 697 | static Handle<SharedFunctionInfo> CompileStreamedScript(CompilationInfo* info, |
| 698 | int source_length); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 699 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 700 | // Create a shared function info object (the code may be lazily compiled). |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 701 | static Handle<SharedFunctionInfo> BuildFunctionInfo(FunctionLiteral* node, |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 702 | Handle<Script> script, |
| 703 | CompilationInfo* outer); |
Steve Block | d0582a6 | 2009-12-15 09:54:21 +0000 | [diff] [blame] | 704 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 705 | enum ConcurrencyMode { NOT_CONCURRENT, CONCURRENT }; |
Andrei Popescu | 3100271 | 2010-02-23 13:46:05 +0000 | [diff] [blame] | 706 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 707 | // Generate and return optimized code or start a concurrent optimization job. |
| 708 | // In the latter case, return the InOptimizationQueue builtin. On failure, |
| 709 | // return the empty handle. |
| 710 | MUST_USE_RESULT static MaybeHandle<Code> GetOptimizedCode( |
| 711 | Handle<JSFunction> function, |
| 712 | Handle<Code> current_code, |
| 713 | ConcurrencyMode mode, |
| 714 | BailoutId osr_ast_id = BailoutId::None()); |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 715 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 716 | // Generate and return code from previously queued optimization job. |
| 717 | // On failure, return the empty handle. |
| 718 | static Handle<Code> GetConcurrentlyOptimizedCode(OptimizedCompileJob* job); |
| 719 | |
| 720 | static bool DebuggerWantsEagerCompilation( |
| 721 | CompilationInfo* info, bool allow_lazy_without_ctx = false); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 722 | }; |
| 723 | |
| 724 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 725 | class CompilationPhase BASE_EMBEDDED { |
| 726 | public: |
| 727 | CompilationPhase(const char* name, CompilationInfo* info); |
| 728 | ~CompilationPhase(); |
| 729 | |
| 730 | protected: |
| 731 | bool ShouldProduceTraceOutput() const; |
| 732 | |
| 733 | const char* name() const { return name_; } |
| 734 | CompilationInfo* info() const { return info_; } |
| 735 | Isolate* isolate() const { return info()->isolate(); } |
| 736 | Zone* zone() { return &zone_; } |
| 737 | |
| 738 | private: |
| 739 | const char* name_; |
| 740 | CompilationInfo* info_; |
| 741 | Zone zone_; |
| 742 | unsigned info_zone_start_allocation_size_; |
| 743 | base::ElapsedTimer timer_; |
| 744 | |
| 745 | DISALLOW_COPY_AND_ASSIGN(CompilationPhase); |
| 746 | }; |
| 747 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 748 | } } // namespace v8::internal |
| 749 | |
| 750 | #endif // V8_COMPILER_H_ |