From 36a4d039b1fb3b547499dcc9f4d474c1e0767bb0 Mon Sep 17 00:00:00 2001
From: "mads.s.ager@gmail.com"
 <mads.s.ager@gmail.com@ce2b1a6d-e550-0410-aec6-3dcde31c8c00>
Date: Mon, 1 Sep 2008 06:06:52 +0000
Subject: [PATCH] Introduce ZoneScope class to keep track of zone deletion. 
 Remove unsafe calls to Zone::DeleteAll() from parser and use ZoneScopes
 instead.

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@54 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
---
 src/compiler.cc | 26 ++------------------------
 src/parser.cc   |  7 +++++--
 src/zone.cc     |  1 +
 src/zone.h      | 33 +++++++++++++++++++++++++++++++++
 4 files changed, 41 insertions(+), 26 deletions(-)

diff --git a/src/compiler.cc b/src/compiler.cc
index 6a79605cb3..7d2e661f5c 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -48,28 +48,6 @@ DEFINE_bool(print_scopes, false, "print scopes");
 #endif
 
 
-// Helper class to keep track of compilation nesting and to do proper
-// cleanups of generated ASTs.
-class CompilationTracker BASE_EMBEDDED {
- public:
-  CompilationTracker() {
-    ++nesting_;
-  }
-
-  ~CompilationTracker() {
-    // If we're leaving the top-level compilation, we must make sure
-    // to get rid of all generated ASTs.
-    if (--nesting_ == 0) Zone::DeleteAll();
-  }
-
- private:
-  static int nesting_;
-};
-
-
-int CompilationTracker::nesting_ = 0;
-
-
 static Handle<Code> MakeCode(FunctionLiteral* literal,
                              Handle<Script> script,
                              bool is_eval) {
@@ -108,7 +86,7 @@ static Handle<JSFunction> MakeFunction(bool is_global,
                                        Handle<Script> script,
                                        v8::Extension* extension,
                                        ScriptDataImpl* pre_data) {
-  CompilationTracker tracker;
+  ZoneScope zone_scope(DELETE_ON_EXIT);
 
   // Make sure we have an initial stack limit.
   StackGuard guard;
@@ -232,7 +210,7 @@ Handle<JSFunction> Compiler::CompileEval(bool is_global,
 
 
 bool Compiler::CompileLazy(Handle<SharedFunctionInfo> shared) {
-  CompilationTracker tracker;
+  ZoneScope zone_scope(DELETE_ON_EXIT);
 
   // The VM is in the COMPILER state until exiting this function.
   VMState state(COMPILER);
diff --git a/src/parser.cc b/src/parser.cc
index 042af9fe4e..d9a65f3a3f 100644
--- a/src/parser.cc
+++ b/src/parser.cc
@@ -731,6 +731,8 @@ bool Parser::PreParseProgram(unibrow::CharacterStream* stream) {
 FunctionLiteral* Parser::ParseProgram(Handle<String> source,
                                       unibrow::CharacterStream* stream,
                                       bool in_global_context) {
+  ZoneScope zone_scope(DONT_DELETE_ON_EXIT);
+
   StatsRateScope timer(&Counters::parse);
   Counters::total_parse_size.Increment(source->length());
 
@@ -773,7 +775,7 @@ FunctionLiteral* Parser::ParseProgram(Handle<String> source,
 
   // If there was a syntax error we have to get rid of the AST
   // and it is not safe to do so before the scope has been deleted.
-  if (result == NULL) Zone::DeleteAll();
+  if (result == NULL) zone_scope.DeleteOnExit();
   return result;
 }
 
@@ -782,6 +784,7 @@ FunctionLiteral* Parser::ParseLazy(Handle<String> source,
                                    Handle<String> name,
                                    int start_position,
                                    bool is_expression) {
+  ZoneScope zone_scope(DONT_DELETE_ON_EXIT);
   StatsRateScope timer(&Counters::parse_lazy);
   Counters::total_parse_size.Increment(source->length());
   SafeStringInputBuffer buffer(source.location());
@@ -819,7 +822,7 @@ FunctionLiteral* Parser::ParseLazy(Handle<String> source,
   // not safe to do before scope has been deleted.
   if (result == NULL) {
     Top::StackOverflow();
-    Zone::DeleteAll();
+    zone_scope.DeleteOnExit();
   }
   return result;
 }
diff --git a/src/zone.cc b/src/zone.cc
index a518a1079d..ed443d871b 100644
--- a/src/zone.cc
+++ b/src/zone.cc
@@ -37,6 +37,7 @@ Address Zone::limit_ = 0;
 
 bool AssertNoZoneAllocation::allow_allocation_ = true;
 
+int ZoneScope::nesting_ = 0;
 
 // Segments represent chunks of memory: They have starting address
 // (encoded in the this pointer) and a size in bytes. Segments are
diff --git a/src/zone.h b/src/zone.h
index 28ac95443e..336fd343a9 100644
--- a/src/zone.h
+++ b/src/zone.h
@@ -31,6 +31,14 @@
 namespace v8 { namespace internal {
 
 
+// Zone scopes are in one of two modes.  Either they delete the zone
+// on exit or they do not.
+enum ZoneScopeMode {
+  DELETE_ON_EXIT,
+  DONT_DELETE_ON_EXIT
+};
+
+
 // The Zone supports very fast allocation of small chunks of
 // memory. The chunks cannot be deallocated individually, but instead
 // the Zone supports deallocating all chunks in one fast
@@ -143,6 +151,31 @@ class ZoneList: public List<T, ZoneListAllocationPolicy> {
 };
 
 
+// ZoneScopes keep track of the current parsing and compilation
+// nesting and cleans up generated ASTs in the Zone when exiting the
+// outer-most scope.
+class ZoneScope BASE_EMBEDDED {
+ public:
+  explicit ZoneScope(ZoneScopeMode mode) : mode_(mode) {
+    nesting_++;
+  }
+
+  ~ZoneScope() {
+    if (--nesting_ == 0 && mode_ == DELETE_ON_EXIT) Zone::DeleteAll();
+  }
+
+  // For ZoneScopes that do not delete on exit by default, call this
+  // method to request deletion on exit.
+  void DeleteOnExit() {
+    mode_ = DELETE_ON_EXIT;
+  }
+
+ private:
+  ZoneScopeMode mode_;
+  static int nesting_;
+};
+
+
 } }  // namespace v8::internal
 
 #endif  // V8_ZONE_H_