One Zone per CompilationInfo.

src/runtime.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1170 matching lines @@
   return isolate->heap()->ToBoolean(obj->map()->is_extensible());
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_RegExpCompile) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 3);
   CONVERT_ARG_HANDLE_CHECKED(JSRegExp, re, 0);
   CONVERT_ARG_HANDLE_CHECKED(String, pattern, 1);
   CONVERT_ARG_HANDLE_CHECKED(String, flags, 2);
-  Handle<Object> result = RegExpImpl::Compile(re, pattern, flags);
+  ZoneScope zone_scope(isolate->runtime_zone(), DELETE_ON_EXIT);

[danno, 2012/06/14 14:22:19]

Why new new ZoneScope here?

[sanjoy, 2012/06/15 09:24:31]

This runtime function is sometimes called without installing a ZoneScope, and it
is always safe (and cheap) to create a new ZoneScope.  But after Yang's change,
I've moved this to the Regexp code, where I think it makes more sense.

+  Handle<Object> result =
+      RegExpImpl::Compile(re, pattern, flags, isolate->runtime_zone());
   if (result.is_null()) return Failure::Exception();
   return *result;
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_CreateApiFunction) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 1);
   CONVERT_ARG_HANDLE_CHECKED(FunctionTemplateInfo, data, 0);
   return *isolate->factory()->CreateApiFunction(data);
@@ skipping 540 matching lines @@
   CONVERT_SMI_ARG_CHECKED(index, 2);
   CONVERT_ARG_HANDLE_CHECKED(JSArray, last_match_info, 3);
   RUNTIME_ASSERT(last_match_info->HasFastObjectElements());
   RUNTIME_ASSERT(index >= 0);
   RUNTIME_ASSERT(index <= subject->length());
   isolate->counters()->regexp_entry_runtime()->Increment();
   Handle<Object> result = RegExpImpl::Exec(regexp,
                                            subject,
                                            index,
                                            last_match_info,
-                                           isolate->zone());
+                                           isolate->runtime_zone());
   if (result.is_null()) return Failure::Exception();
   return *result;
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_RegExpConstructResult) {
   ASSERT(args.length() == 3);
   CONVERT_SMI_ARG_CHECKED(elements_count, 0);
   if (elements_count < 0 ||
       elements_count > FixedArray::kMaxLength ||
@@ skipping 1219 matching lines @@
 MUST_USE_RESULT static MaybeObject* StringReplaceAtomRegExpWithString(
     Isolate* isolate,
     Handle<String> subject,
     Handle<JSRegExp> pattern_regexp,
     Handle<String> replacement,
     Handle<JSArray> last_match_info,
     Zone* zone) {
   ASSERT(subject->IsFlat());
   ASSERT(replacement->IsFlat());
 
-  ZoneScope zone_space(isolate, DELETE_ON_EXIT);
-  ZoneList<int> indices(8, isolate->zone());
+  ZoneScope zone_space(isolate->runtime_zone(), DELETE_ON_EXIT);
+  ZoneList<int> indices(8, isolate->runtime_zone());
   ASSERT_EQ(JSRegExp::ATOM, pattern_regexp->TypeTag());
   String* pattern =
       String::cast(pattern_regexp->DataAt(JSRegExp::kAtomPatternIndex));
   int subject_len = subject->length();
   int pattern_len = pattern->length();
   int replacement_len = replacement->length();
 
   FindStringIndicesDispatch(isolate, *subject, pattern, &indices, 0xffffffff,
                             zone);
 
@@ skipping 73 matching lines @@
 
   int length = subject->length();
   Handle<String> subject_handle(subject);
   Handle<JSRegExp> regexp_handle(regexp);
   Handle<String> replacement_handle(replacement);
   Handle<JSArray> last_match_info_handle(last_match_info);
   Handle<Object> match = RegExpImpl::Exec(regexp_handle,
                                           subject_handle,
                                           0,
                                           last_match_info_handle,
-                                          isolate->zone());
+                                          zone);
   if (match.is_null()) {
     return Failure::Exception();
   }
   if (match->IsNull()) {
     return *subject_handle;
   }
 
   int capture_count = regexp_handle->CaptureCount();
 
   // CompiledReplacement uses zone allocation.
-  ZoneScope zonescope(isolate, DELETE_ON_EXIT);
-  CompiledReplacement compiled_replacement(isolate->zone());
+  ZoneScope zonescope(zone, DELETE_ON_EXIT);
+  CompiledReplacement compiled_replacement(zone);
   compiled_replacement.Compile(replacement_handle,
                                capture_count,
                                length);
 
   bool is_global = regexp_handle->GetFlags().is_global();
 
   // Shortcut for simple non-regexp global replacements
   if (is_global &&
       regexp_handle->TypeTag() == JSRegExp::ATOM &&
       compiled_replacement.simple_hint()) {
@@ skipping 69 matching lines @@
     int next = end;
     if (start == end) {
       next = end + 1;
       if (next > length) break;
     }
 
     match = RegExpImpl::Exec(regexp_handle,
                              subject_handle,
                              next,
                              last_match_info_handle,
-                             isolate->zone());
+                             zone);
     if (match.is_null()) {
       return Failure::Exception();
     }
     matched = !match->IsNull();
   } while (matched);
 
   if (prev < length) {
     builder.AddSubjectSlice(prev, length);
   }
 
@@ skipping 36 matching lines @@
           empty_string_handle,
           last_match_info_handle,
           zone);
     }
   }
 
   Handle<Object> match = RegExpImpl::Exec(regexp_handle,
                                           subject_handle,
                                           0,
                                           last_match_info_handle,
-                                          isolate->zone());
+                                          zone);
   if (match.is_null()) return Failure::Exception();
   if (match->IsNull()) return *subject_handle;
 
   ASSERT(last_match_info_handle->HasFastObjectElements());
 
   int start, end;
   {
     AssertNoAllocation match_info_array_is_not_in_a_handle;
     FixedArray* match_info_array =
         FixedArray::cast(last_match_info_handle->elements());
@@ skipping 54 matching lines @@
     next = end;
     // Continue from where the match ended, unless it was an empty match.
     if (start == end) {
       next++;
       if (next > length) break;
     }
     match = RegExpImpl::Exec(regexp_handle,
                              subject_handle,
                              next,
                              last_match_info_handle,
-                             isolate->zone());
+                             zone);
     if (match.is_null()) return Failure::Exception();
     if (match->IsNull()) break;
 
     ASSERT(last_match_info_handle->HasFastObjectElements());
     HandleScope loop_scope(isolate);
     {
       AssertNoAllocation match_info_array_is_not_in_a_handle;
       FixedArray* match_info_array =
           FixedArray::cast(last_match_info_handle->elements());
       start = RegExpImpl::GetCapture(match_info_array, 0);
@@ skipping 55 matching lines @@
       }
     }
     replacement = String::cast(flat_replacement);
   }
 
   CONVERT_ARG_CHECKED(JSRegExp, regexp, 1);
   CONVERT_ARG_CHECKED(JSArray, last_match_info, 3);
 
   ASSERT(last_match_info->HasFastObjectElements());
 
-  Zone* zone = isolate->zone();
+  Zone* zone = isolate->runtime_zone();
   if (replacement->length() == 0) {
     if (subject->HasOnlyAsciiChars()) {
       return StringReplaceRegExpWithEmptyString<SeqAsciiString>(
           isolate, subject, regexp, last_match_info, zone);
     } else {
       return StringReplaceRegExpWithEmptyString<SeqTwoByteString>(
           isolate, subject, regexp, last_match_info, zone);
     }
   }
 
@@ skipping 318 matching lines @@
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_StringMatch) {
   ASSERT_EQ(3, args.length());
 
   CONVERT_ARG_HANDLE_CHECKED(String, subject, 0);
   CONVERT_ARG_HANDLE_CHECKED(JSRegExp, regexp, 1);
   CONVERT_ARG_HANDLE_CHECKED(JSArray, regexp_info, 2);
   HandleScope handles;
 
+  Zone* zone = isolate->runtime_zone();
   Handle<Object> match = RegExpImpl::Exec(regexp, subject, 0, regexp_info,
-                                          isolate->zone());
+                                          zone);
 
   if (match.is_null()) {
     return Failure::Exception();
   }
   if (match->IsNull()) {
     return isolate->heap()->null_value();
   }
   int length = subject->length();
 
-  Zone* zone = isolate->zone();
-  ZoneScope zone_space(isolate, DELETE_ON_EXIT);
+  ZoneScope zone_space(zone, DELETE_ON_EXIT);
   ZoneList<int> offsets(8, zone);
   int start;
   int end;
   do {
     {
       AssertNoAllocation no_alloc;
       FixedArray* elements = FixedArray::cast(regexp_info->elements());
       start = Smi::cast(elements->get(RegExpImpl::kFirstCapture))->value();
       end = Smi::cast(elements->get(RegExpImpl::kFirstCapture + 1))->value();
     }
     offsets.Add(start, zone);
     offsets.Add(end, zone);
     if (start == end) if (++end > length) break;
     match = RegExpImpl::Exec(regexp, subject, end, regexp_info,
-                             isolate->zone());
+                             zone);
     if (match.is_null()) {
       return Failure::Exception();
     }
   } while (!match->IsNull());
   int matches = offsets.length() / 2;
   Handle<FixedArray> elements = isolate->factory()->NewFixedArray(matches);
   Handle<String> substring = isolate->factory()->
     NewSubString(subject, offsets.at(0), offsets.at(1));
   elements->set(0, *substring);
   for (int i = 1; i < matches ; i++) {
@@ skipping 74 matching lines @@
 
 
 static int SearchRegExpNoCaptureMultiple(
     Isolate* isolate,
     Handle<String> subject,
     Handle<JSRegExp> regexp,
     Handle<JSArray> last_match_array,
     FixedArrayBuilder* builder) {
   ASSERT(subject->IsFlat());
   ASSERT(regexp->CaptureCount() == 0);
+  Zone* zone = isolate->runtime_zone();
   int match_start = -1;
   int match_end = 0;
   int pos = 0;
   int registers_per_match = RegExpImpl::IrregexpPrepare(regexp, subject,
-                                                        isolate->zone());
+                                                        zone);
   if (registers_per_match < 0) return RegExpImpl::RE_EXCEPTION;
 
   int max_matches;
   int num_registers = RegExpImpl::GlobalOffsetsVectorSize(regexp,
                                                           registers_per_match,
                                                           &max_matches);
   OffsetsVector registers(num_registers, isolate);
   Vector<int32_t> register_vector(registers.vector(), registers.length());
   int subject_length = subject->length();
   bool first = true;
   for (;;) {  // Break on failure, return on exception.
     int num_matches = RegExpImpl::IrregexpExecRaw(regexp,
                                                   subject,
                                                   pos,
                                                   register_vector,
-                                                  isolate->zone());
+                                                  zone);
     if (num_matches > 0) {
       for (int match_index = 0; match_index < num_matches; match_index++) {
         int32_t* current_match = &register_vector[match_index * 2];
         match_start = current_match[0];
         builder->EnsureCapacity(kMaxBuilderEntriesPerRegExpMatch);
         if (match_end < match_start) {
           ReplacementStringBuilder::AddSubjectSlice(builder,
                                                     match_end,
                                                     match_start);
         }
@@ skipping 46 matching lines @@
 }
 
 
 // Only called from Runtime_RegExpExecMultiple so it doesn't need to maintain
 // separate last match info.  See comment on that function.
 static int SearchRegExpMultiple(
     Isolate* isolate,
     Handle<String> subject,
     Handle<JSRegExp> regexp,
     Handle<JSArray> last_match_array,
-    FixedArrayBuilder* builder) {
+    FixedArrayBuilder* builder,
+    Zone* zone) {
 
   ASSERT(subject->IsFlat());
   int registers_per_match = RegExpImpl::IrregexpPrepare(regexp, subject,
-                                                        isolate->zone());
+                                                        zone);
   if (registers_per_match < 0) return RegExpImpl::RE_EXCEPTION;
 
   int max_matches;
   int num_registers = RegExpImpl::GlobalOffsetsVectorSize(regexp,
                                                           registers_per_match,
                                                           &max_matches);
   OffsetsVector registers(num_registers, isolate);
   Vector<int32_t> register_vector(registers.vector(), registers.length());
 
   int num_matches = RegExpImpl::IrregexpExecRaw(regexp,
                                                 subject,
                                                 0,
                                                 register_vector,
-                                                isolate->zone());
+                                                zone);
 
   int capture_count = regexp->CaptureCount();
   int subject_length = subject->length();
 
   // Position to search from.
   int pos = 0;
   // End of previous match. Differs from pos if match was empty.
   int match_end = 0;
   bool first = true;
 
@@ skipping 66 matching lines @@
         pos = match_end + 1;
         if (pos > subject_length) {
           break;
         }
       }
 
       num_matches = RegExpImpl::IrregexpExecRaw(regexp,
                                                 subject,
                                                 pos,
                                                 register_vector,
-                                                isolate->zone());
+                                                zone);
     } while (num_matches > 0);
 
     if (num_matches != RegExpImpl::RE_EXCEPTION) {
       // Finished matching, with at least one match.
       if (match_end < subject_length) {
         ReplacementStringBuilder::AddSubjectSlice(builder,
                                                   match_end,
                                                   subject_length);
       }
 
@@ skipping 60 matching lines @@
     result = SearchRegExpNoCaptureMultiple(isolate,
                                            subject,
                                            regexp,
                                            last_match_info,
                                            &builder);
   } else {
     result = SearchRegExpMultiple(isolate,
                                   subject,
                                   regexp,
                                   last_match_info,
-                                  &builder);
+                                  &builder,
+                                  isolate->runtime_zone());
   }
   if (result == RegExpImpl::RE_SUCCESS) return *builder.ToJSArray(result_array);
   if (result == RegExpImpl::RE_FAILURE) return isolate->heap()->null_value();
   ASSERT_EQ(result, RegExpImpl::RE_EXCEPTION);
   return Failure::Exception();
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_NumberToRadixString) {
   NoHandleAllocation ha;
@@ skipping 2314 matching lines @@
   }
 
   // The limit can be very large (0xffffffffu), but since the pattern
   // isn't empty, we can never create more parts than ~half the length
   // of the subject.
 
   if (!subject->IsFlat()) FlattenString(subject);
 
   static const int kMaxInitialListCapacity = 16;
 
-  Zone* zone = isolate->zone();
-  ZoneScope scope(isolate, DELETE_ON_EXIT);
+  Zone* zone = isolate->runtime_zone();
+  ZoneScope scope(zone, DELETE_ON_EXIT);
 
   // Find (up to limit) indices of separator and end-of-string in subject
   int initial_capacity = Min<uint32_t>(kMaxInitialListCapacity, limit);
   ZoneList<int> indices(initial_capacity, zone);
   if (!pattern->IsFlat()) FlattenString(pattern);
 
   FindStringIndicesDispatch(isolate, *subject, *pattern, &indices, limit, zone);
 
   if (static_cast<uint32_t>(indices.length()) < limit) {
     indices.Add(subject_length, zone);
@@ skipping 2828 matching lines @@
   if (!global->IsJSGlobalObject()) return isolate->heap()->null_value();
   return JSGlobalObject::cast(global)->global_receiver();
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_ParseJson) {
   HandleScope scope(isolate);
   ASSERT_EQ(1, args.length());
   CONVERT_ARG_HANDLE_CHECKED(String, source, 0);
 
-  Zone* zone = isolate->zone();
+  Zone* zone = isolate->runtime_zone();
   source = Handle<String>(source->TryFlattenGetString());
   // Optimized fast case where we only have ASCII characters.
   Handle<Object> result;
   if (source->IsSeqAsciiString()) {
     result = JsonParser<true>::Parse(source, zone);
   } else {
     result = JsonParser<false>::Parse(source, zone);
   }
   if (result.is_null()) {
     // Syntax error or stack overflow in scanner.
@@ skipping 1810 matching lines @@
   ScopeIterator(Isolate* isolate,
                 JavaScriptFrame* frame,
                 int inlined_jsframe_index)
     : isolate_(isolate),
       frame_(frame),
       inlined_jsframe_index_(inlined_jsframe_index),
       function_(JSFunction::cast(frame->function())),
       context_(Context::cast(frame->context())),
       nested_scope_chain_(4) {
 
+    Zone zone(isolate);

[danno, 2012/06/14 14:22:19]

Why put this here and not closer to the CompilationInfos? If you put the Zone
and ZoneScope directly into the CompilationInfo, you can even get rid of these.

[sanjoy, 2012/06/15 09:24:31]

Because below a Scope allocated inside a Zone is being used outside the lexical
scope of the corresponding CompilationInfo (line 11210, 11219).

Plus, I think it keeps the design a little bit more flexible.

+    ZoneScope zone_scope(&zone, DELETE_ON_EXIT);
     // Catch the case when the debugger stops in an internal function.
     Handle<SharedFunctionInfo> shared_info(function_->shared());
     Handle<ScopeInfo> scope_info(shared_info->scope_info());
     if (shared_info->script() == isolate->heap()->undefined_value()) {
       while (context_->closure() == *function_) {
         context_ = Handle<Context>(context_->previous(), isolate_);
       }
       return;
     }
 
@@ skipping 16 matching lines @@
       if (scope_info->HasContext()) {
         context_ = Handle<Context>(context_->declaration_context(), isolate_);
       } else {
         while (context_->closure() == *function_) {
           context_ = Handle<Context>(context_->previous(), isolate_);
         }
       }
       if (scope_info->Type() != EVAL_SCOPE) nested_scope_chain_.Add(scope_info);
     } else {
       // Reparse the code and analyze the scopes.
-      ZoneScope zone_scope(isolate, DELETE_ON_EXIT);
       Handle<Script> script(Script::cast(shared_info->script()));
       Scope* scope = NULL;
 
       // Check whether we are in global, eval or function code.
       Handle<ScopeInfo> scope_info(shared_info->scope_info());
       if (scope_info->Type() != FUNCTION_SCOPE) {
         // Global or eval code.
-        CompilationInfo info(script);
+        CompilationInfo info(script, &zone);
         if (scope_info->Type() == GLOBAL_SCOPE) {
           info.MarkAsGlobal();
         } else {
           ASSERT(scope_info->Type() == EVAL_SCOPE);
           info.MarkAsEval();
           info.SetCallingContext(Handle<Context>(function_->context()));
         }
         if (ParserApi::Parse(&info, kNoParsingFlags) && Scope::Analyze(&info)) {
           scope = info.function()->scope();
         }
       } else {
         // Function code
-        CompilationInfo info(shared_info);
+        CompilationInfo info(shared_info, &zone);
         if (ParserApi::Parse(&info, kNoParsingFlags) && Scope::Analyze(&info)) {
           scope = info.function()->scope();
         }
       }
 
       // Retrieve the scope chain for the current position.
       if (scope != NULL) {
         int source_position = shared_info->code()->SourcePosition(frame_->pc());
         scope->GetNestedScopeChain(&nested_scope_chain_, source_position);
       } else {
@@ skipping 1554 matching lines @@
 // checks that none of them have activations on stacks (of any thread).
 // Returns array of the same length with corresponding results of
 // LiveEdit::FunctionPatchabilityStatus type.
 RUNTIME_FUNCTION(MaybeObject*, Runtime_LiveEditCheckAndDropActivations) {
   ASSERT(args.length() == 2);
   HandleScope scope(isolate);
   CONVERT_ARG_HANDLE_CHECKED(JSArray, shared_array, 0);
   CONVERT_BOOLEAN_ARG_CHECKED(do_drop, 1);
 
   return *LiveEdit::CheckAndDropActivations(shared_array, do_drop,
-                                            isolate->zone());
+                                            isolate->runtime_zone());
 }
 
 // Compares 2 strings line-by-line, then token-wise and returns diff in form
 // of JSArray of triplets (pos1, pos1_end, pos2_end) describing list
 // of diff chunks.
 RUNTIME_FUNCTION(MaybeObject*, Runtime_LiveEditCompareStrings) {
   ASSERT(args.length() == 2);
   HandleScope scope(isolate);
   CONVERT_ARG_HANDLE_CHECKED(String, s1, 0);
   CONVERT_ARG_HANDLE_CHECKED(String, s2, 1);
@@ skipping 805 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal