Revert of Refactor compilation dependency handling.

src/compiler.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_COMPILER_H_
 #define V8_COMPILER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
-#include "src/compilation-dependencies.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
 class AstValueFactory;
 class HydrogenCodeStub;
 class ParseInfo;
 class ScriptData;
 
@@ skipping 271 matching lines @@
   }
 
   // Determines whether or not to insert a self-optimization header.
   bool ShouldSelfOptimize();
 
   void set_deferred_handles(DeferredHandles* deferred_handles) {
     DCHECK(deferred_handles_ == NULL);
     deferred_handles_ = deferred_handles;
   }
 
+  ZoneList<Handle<HeapObject> >* dependencies(
+      DependentCode::DependencyGroup group) {
+    if (dependencies_[group] == NULL) {
+      dependencies_[group] = new(zone_) ZoneList<Handle<HeapObject> >(2, zone_);
+    }
+    return dependencies_[group];
+  }
+
+  void CommitDependencies(Handle<Code> code);
+
+  void RollbackDependencies();
+
   void ReopenHandlesInNewHandleScope() {
     unoptimized_code_ = Handle<Code>(*unoptimized_code_);
   }
 
   void AbortOptimization(BailoutReason reason) {
     DCHECK(reason != kNoReason);
     if (bailout_reason_ == kNoReason) bailout_reason_ = reason;
     SetFlag(kDisableFutureOptimization);
   }
 
@@ skipping 32 matching lines @@
     return inlined_function_infos_.at(inlining_id).start_position;
   }
   const std::vector<InlinedFunctionInfo>& inlined_function_infos() {
     return inlined_function_infos_;
   }
 
   void LogDeoptCallPosition(int pc_offset, int inlining_id);
   int TraceInlinedFunction(Handle<SharedFunctionInfo> shared,
                            SourcePosition position, int pareint_id);
 
-  CompilationDependencies* dependencies() { return &dependencies_; }
+  Handle<Foreign> object_wrapper() {
+    if (object_wrapper_.is_null()) {
+      object_wrapper_ =
+          isolate()->factory()->NewForeign(reinterpret_cast<Address>(this));
+    }
+    return object_wrapper_;
+  }
+
+  void AbortDueToDependencyChange() {
+    aborted_due_to_dependency_change_ = true;
+  }
+
+  bool HasAbortedDueToDependencyChange() const {
+    return aborted_due_to_dependency_change_;
+  }
 
   bool HasSameOsrEntry(Handle<JSFunction> function, BailoutId osr_ast_id) {
     return osr_ast_id_ == osr_ast_id && function.is_identical_to(closure());
   }
 
   int optimization_id() const { return optimization_id_; }
 
   int osr_expr_stack_height() { return osr_expr_stack_height_; }
   void set_osr_expr_stack_height(int height) {
     DCHECK(height >= 0);
@@ skipping 62 matching lines @@
   // afterwards, since we may need to compile it again to include deoptimization
   // data.  Keep track which code we patched.
   Handle<Code> unoptimized_code_;
 
   // The zone from which the compilation pipeline working on this
   // CompilationInfo allocates.
   Zone* zone_;
 
   DeferredHandles* deferred_handles_;
 
-  // Dependencies for this compilation, e.g. stable maps.
-  CompilationDependencies dependencies_;
+  ZoneList<Handle<HeapObject> >* dependencies_[DependentCode::kGroupCount];
 
   BailoutReason bailout_reason_;
 
   int prologue_offset_;
 
   List<OffsetRange>* no_frame_ranges_;
   std::vector<InlinedFunctionInfo> inlined_function_infos_;
   bool track_positions_;
 
   // A copy of shared_info()->opt_count() to avoid handle deref
   // during graph optimization.
   int opt_count_;
 
   // Number of parameters used for compilation of stubs that require arguments.
   int parameter_count_;
 
+  Handle<Foreign> object_wrapper_;
+
   int optimization_id_;
 
+  // This flag is used by the main thread to track whether this compilation
+  // should be abandoned due to dependency change.
+  bool aborted_due_to_dependency_change_;
+
   int osr_expr_stack_height_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilationInfo);
 };
 
 
 // A wrapper around a CompilationInfo that detaches the Handles from
 // the underlying DeferredHandleScope and stores them in info_ on
 // destruction.
 class CompilationHandleScope BASE_EMBEDDED {
@@ skipping 192 matching lines @@
   Zone zone_;
   size_t info_zone_start_allocation_size_;
   base::ElapsedTimer timer_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilationPhase);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_COMPILER_H_