Refactor allocation policies.

src/runtime.cc

 // Copyright 2011 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 2314 matching lines @@
   Heap* heap_;
   FixedArrayBuilder array_builder_;
   Handle<String> subject_;
   int character_count_;
   bool is_ascii_;
 };
 
 
 class CompiledReplacement {
  public:
-  CompiledReplacement()
-      : parts_(1), replacement_substrings_(0) {}
+  explicit CompiledReplacement(Zone* zone)
+      : parts_(zone, 1), replacement_substrings_(zone, 0) {}
 
   void Compile(Handle<String> replacement,
                int capture_count,
                int subject_length);
 
   void Apply(ReplacementStringBuilder* builder,
              int match_from,
              int match_to,
              Handle<JSArray> last_match_info);
 
@@ skipping 271 matching lines @@
   if (match.is_null()) {
     return Failure::Exception();
   }
   if (match->IsNull()) {
     return *subject_handle;
   }
 
   int capture_count = regexp_handle->CaptureCount();
 
   // CompiledReplacement uses zone allocation.
-  ZoneScope zone(isolate, DELETE_ON_EXIT);
-  CompiledReplacement compiled_replacement;
+  ZoneScope zone_scope(isolate, DELETE_ON_EXIT);
+  CompiledReplacement compiled_replacement(isolate->zone());
   compiled_replacement.Compile(replacement_handle,
                                capture_count,
                                length);
 
   bool is_global = regexp_handle->GetFlags().is_global();
 
   // Guessing the number of parts that the final result string is built
   // from. Global regexps can match any number of times, so we guess
   // conservatively.
   int expected_parts =
@@ skipping 493 matching lines @@
 
   if (match.is_null()) {
     return Failure::Exception();
   }
   if (match->IsNull()) {
     return isolate->heap()->null_value();
   }
   int length = subject->length();
 
   ZoneScope zone_space(isolate, DELETE_ON_EXIT);
-  ZoneList<int> offsets(8);
+  ZoneList<int> offsets(isolate->zone(), 8);
   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);
@@ skipping 2649 matching lines @@
   // of the subject.
 
   if (!subject->IsFlat()) FlattenString(subject);
 
   static const int kMaxInitialListCapacity = 16;
 
   ZoneScope scope(isolate, 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);
+  ZoneList<int> indices(isolate->zone(), initial_capacity);
   if (!pattern->IsFlat()) FlattenString(pattern);
 
   // No allocation block.
   {
     AssertNoAllocation nogc;
     if (subject->IsAsciiRepresentation()) {
       Vector<const char> subject_vector = subject->ToAsciiVector();
       if (pattern->IsAsciiRepresentation()) {
         Vector<const char> pattern_vector = pattern->ToAsciiVector();
         if (pattern_vector.length() == 1) {
@@ skipping 6845 matching lines @@
   } else {
     // 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(false);
   }
 }
 
 
 } }  // namespace v8::internal