Refactor compilation dependency handling.

src/dependencies.h

Index: src/dependencies.h
diff --git a/src/dependencies.h b/src/dependencies.h
new file mode 100644
index 0000000000000000000000000000000000000000..ddd0be83bdaa15e0f1caf292859df17cc9696257
--- /dev/null
+++ b/src/dependencies.h
@@ -0,0 +1,67 @@
+// Copyright 2015 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_DEPENDENCIES_H_

[Michael Starzinger, 2015/04/16 14:36:42]

suggestion: What do you think about calling this file
"compilation-dependencies.h" instead?

[titzer, 2015/04/16 14:47:26]

Done.

+#define V8_DEPENDENCIES_H_
+
+namespace v8 {
+namespace internal {
+
+// Collects dependencies for this compilation, e.g. assumptions about
+// stable maps, constant globals, etc.
+class CompilationDependencies {
+ public:
+  CompilationDependencies(Isolate* isolate, Zone* zone)
+      : isolate_(isolate),
+        zone_(zone),
+        object_wrapper_(Handle<Foreign>::null()),
+        aborted_(false) {
+    std::fill_n(groups_, DependentCode::kGroupCount, nullptr);
+  }
+
+  void Insert(DependentCode::DependencyGroup group, Handle<HeapObject> handle);
+
+  void AssumeInitialMapCantChange(Handle<Map> map) {
+    Insert(DependentCode::kInitialMapChangedGroup, map);
+  }
+  void AssumeElementsCantBeAdded(Handle<Map> map) {
+    Insert(DependentCode::kElementsCantBeAddedGroup, map);
+  }
+  void AssumeFieldType(Handle<Map> map) {
+    Insert(DependentCode::kFieldTypeGroup, map);
+  }
+  void AssumePropertyCell(Handle<PropertyCell> cell) {

[Michael Starzinger, 2015/04/16 14:36:42]

nit: Maybe AssumePropertyCellValue() or AssumePropertyCellContent() is clearer?

[titzer, 2015/04/16 14:47:26]

As discussed in person, we take dependencies on property cells if the code
depends either on it being a constant or just existing (i.e. not being deleted).
We could separate the cases in the future.

+    Insert(DependentCode::kPropertyCellChangedGroup, cell);
+  }
+  void AssumeTenuringDecision(Handle<AllocationSite> site) {
+    Insert(DependentCode::kAllocationSiteTenuringChangedGroup, site);
+  }
+  void AssumeTransitionStable(Handle<AllocationSite> site);
+
+  void Commit(Handle<Code> code);
+  void Rollback();
+  void Abort() { aborted_ = true; }
+  bool HasAborted() const { return aborted_; }
+
+  bool IsEmpty() const {
+    for (int i = 0; i < DependentCode::kGroupCount; i++) {
+      if (groups_[i]) return false;
+    }
+    return true;
+  }
+
+ private:
+  Isolate* isolate_;
+  Zone* zone_;
+  Handle<Foreign> object_wrapper_;
+  bool aborted_;
+  ZoneList<Handle<HeapObject> >* groups_[DependentCode::kGroupCount];
+
+  DependentCode* Get(Handle<Object> object);
+  void Set(Handle<Object> object, Handle<DependentCode> dep);
+};
+}
+}  // namespace v8::internal
+
+#endif  // V8_DEPENDENCIES_H_