Refactor allocation policies.

src/jsregexp.cc

 // Copyright 2006-2009 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 778 matching lines @@
 int TextElement::length() {
   if (type == ATOM) {
     return data.u_atom->length();
   } else {
     ASSERT(type == CHAR_CLASS);
     return 1;
   }
 }
 
 
-DispatchTable* ChoiceNode::GetTable(bool ignore_case) {
+DispatchTable* ChoiceNode::GetTable(Zone* zone, bool ignore_case) {
   if (table_ == NULL) {
-    table_ = new DispatchTable();
-    DispatchTableConstructor cons(table_, ignore_case);
+    table_ = new DispatchTable(zone);
+    DispatchTableConstructor cons(zone, table_, ignore_case);
     cons.BuildTable(this);
   }
   return table_;
 }
 
 
 class RegExpCompiler {
  public:
-  RegExpCompiler(int capture_count, bool ignore_case, bool is_ascii);
+  RegExpCompiler(Isolate* isolate,
+                 int capture_count,
+                 bool ignore_case,
+                 bool is_ascii);
+
+  Isolate* isolate() { return isolate_; }
+  Zone* zone() { return isolate()->zone(); }
 
   int AllocateRegister() {
     if (next_register_ >= RegExpMacroAssembler::kMaxRegister) {
       reg_exp_too_big_ = true;
       return next_register_;
     }
     return next_register_++;
   }
 
   RegExpEngine::CompilationResult Assemble(RegExpMacroAssembler* assembler,
@@ skipping 21 matching lines @@
   inline bool ascii() { return ascii_; }
 
   int current_expansion_factor() { return current_expansion_factor_; }
   void set_current_expansion_factor(int value) {
     current_expansion_factor_ = value;
   }
 
   static const int kNoRegister = -1;
 
  private:
+  Isolate* isolate_;
   EndNode* accept_;
   int next_register_;
   List<RegExpNode*>* work_list_;
   int recursion_depth_;
   RegExpMacroAssembler* macro_assembler_;
   bool ignore_case_;
   bool ascii_;
   bool reg_exp_too_big_;
   int current_expansion_factor_;
 };
@@ skipping 10 matching lines @@
 };
 
 
 static RegExpEngine::CompilationResult IrregexpRegExpTooBig() {
   return RegExpEngine::CompilationResult("RegExp too big");
 }
 
 
 // Attempts to compile the regexp using an Irregexp code generator.  Returns
 // a fixed array or a null handle depending on whether it succeeded.
-RegExpCompiler::RegExpCompiler(int capture_count, bool ignore_case, bool ascii)
-    : next_register_(2 * (capture_count + 1)),
+RegExpCompiler::RegExpCompiler(Isolate* isolate,
+                               int capture_count,
+                               bool ignore_case,
+                               bool ascii)
+    : isolate_(isolate),
+      next_register_(2 * (capture_count + 1)),
       work_list_(NULL),
       recursion_depth_(0),
       ignore_case_(ignore_case),
       ascii_(ascii),
       reg_exp_too_big_(false),
       current_expansion_factor_(1) {
   accept_ = new EndNode(EndNode::ACCEPT);
   ASSERT(next_register_ - 1 <= RegExpMacroAssembler::kMaxRegister);
 }
 
@@ skipping 82 matching lines @@
         return true;
       } else {
         return false;
       }
     }
   }
   return false;
 }
 
 
-int Trace::FindAffectedRegisters(OutSet* affected_registers) {
+int Trace::FindAffectedRegisters(Zone* zone, OutSet* affected_registers) {
   int max_register = RegExpCompiler::kNoRegister;
   for (DeferredAction* action = actions_;
        action != NULL;
        action = action->next()) {
     if (action->type() == ActionNode::CLEAR_CAPTURES) {
       Interval range = static_cast<DeferredClearCaptures*>(action)->range();
-      for (int i = range.from(); i <= range.to(); i++)
-        affected_registers->Set(i);
+      for (int i = range.from(); i <= range.to(); i++) {
+        affected_registers->Set(zone, i);
+      }
       if (range.to() > max_register) max_register = range.to();
     } else {
-      affected_registers->Set(action->reg());
+      affected_registers->Set(zone, action->reg());
       if (action->reg() > max_register) max_register = action->reg();
     }
   }
   return max_register;
 }
 
 
 void Trace::RestoreAffectedRegisters(RegExpMacroAssembler* assembler,
                                      int max_register,
                                      OutSet& registers_to_pop,
                                      OutSet& registers_to_clear) {
   for (int reg = max_register; reg >= 0; reg--) {
     if (registers_to_pop.Get(reg)) assembler->PopRegister(reg);
     else if (registers_to_clear.Get(reg)) {
       int clear_to = reg;
       while (reg > 0 && registers_to_clear.Get(reg - 1)) {
         reg--;
       }
       assembler->ClearRegisters(reg, clear_to);
     }
   }
 }
 
 
-void Trace::PerformDeferredActions(RegExpMacroAssembler* assembler,
+void Trace::PerformDeferredActions(Zone* zone,
+                                   RegExpMacroAssembler* assembler,
                                    int max_register,
                                    OutSet& affected_registers,
                                    OutSet* registers_to_pop,
                                    OutSet* registers_to_clear) {
   // The "+1" is to avoid a push_limit of zero if stack_limit_slack() is 1.
   const int push_limit = (assembler->stack_limit_slack() + 1) / 2;
 
   // Count pushes performed to force a stack limit check occasionally.
   int pushes = 0;
 
@@ skipping 89 matching lines @@
     if (undo_action == RESTORE) {
       pushes++;
       RegExpMacroAssembler::StackCheckFlag stack_check =
           RegExpMacroAssembler::kNoStackLimitCheck;
       if (pushes == push_limit) {
         stack_check = RegExpMacroAssembler::kCheckStackLimit;
         pushes = 0;
       }
 
       assembler->PushRegister(reg, stack_check);
-      registers_to_pop->Set(reg);
+      registers_to_pop->Set(zone, reg);
     } else if (undo_action == CLEAR) {
-      registers_to_clear->Set(reg);
+      registers_to_clear->Set(zone, reg);
     }
     // Perform the chronologically last action (or accumulated increment)
     // for the register.
     if (store_position != -1) {
       assembler->WriteCurrentPositionToRegister(reg, store_position);
     } else if (clear) {
       assembler->ClearRegisters(reg, reg);
     } else if (absolute) {
       assembler->SetRegister(reg, value);
     } else if (value != 0) {
@@ skipping 25 matching lines @@
   // Generate deferred actions here along with code to undo them again.
   OutSet affected_registers;
 
   if (backtrack() != NULL) {
     // Here we have a concrete backtrack location.  These are set up by choice
     // nodes and so they indicate that we have a deferred save of the current
     // position which we may need to emit here.
     assembler->PushCurrentPosition();
   }
 
-  int max_register = FindAffectedRegisters(&affected_registers);
+  int max_register = FindAffectedRegisters(compiler->zone(),
+                                           &affected_registers);
   OutSet registers_to_pop;
   OutSet registers_to_clear;
-  PerformDeferredActions(assembler,
+  PerformDeferredActions(compiler->zone(),
+                         assembler,
                          max_register,
                          affected_registers,
                          &registers_to_pop,
                          &registers_to_clear);
   if (cp_offset_ != 0) {
     assembler->AdvanceCurrentPosition(cp_offset_);
   }
 
   // Create a new trivial state and generate the node with that.
   Label undo;
@@ skipping 60 matching lines @@
       assembler->GoTo(trace->backtrack());
       return;
     case NEGATIVE_SUBMATCH_SUCCESS:
       // This case is handled in a different virtual method.
       UNREACHABLE();
   }
   UNIMPLEMENTED();
 }
 
 
-void GuardedAlternative::AddGuard(Guard* guard) {
+void GuardedAlternative::AddGuard(Zone* zone, Guard* guard) {
   if (guards_ == NULL)
-    guards_ = new ZoneList<Guard*>(1);
+    guards_ = ZoneList<Guard*>::New(zone, 1);
   guards_->Add(guard);
 }
 
 
 ActionNode* ActionNode::SetRegister(int reg,
                                     int val,
                                     RegExpNode* on_success) {
   ActionNode* result = new ActionNode(SET_REGISTER, on_success);
   result->data_.u_store_register.reg = reg;
   result->data_.u_store_register.value = val;
@@ skipping 271 matching lines @@
       macro_assembler->Bind(&ok);
       break;
     default:
       UNREACHABLE();
       break;
   }
   return true;
 }
 
 
-static void EmitCharClass(RegExpMacroAssembler* macro_assembler,
+static void EmitCharClass(Zone* zone,
+                          RegExpMacroAssembler* macro_assembler,
                           RegExpCharacterClass* cc,
                           bool ascii,
                           Label* on_failure,
                           int cp_offset,
                           bool check_offset,
                           bool preloaded) {
-  ZoneList<CharacterRange>* ranges = cc->ranges();
+  ZoneList<CharacterRange>* ranges = cc->ranges(zone);
   int max_char;
   if (ascii) {
     max_char = String::kMaxAsciiCharCode;
   } else {
     max_char = String::kMaxUC16CharCode;
   }
 
   Label success;
 
   Label* char_is_in_class =
@@ skipping 29 matching lines @@
     if (check_offset) {
       macro_assembler->CheckPosition(cp_offset, on_failure);
     }
     return;
   }
 
   if (!preloaded) {
     macro_assembler->LoadCurrentCharacter(cp_offset, on_failure, check_offset);
   }
 
-  if (cc->is_standard() &&
-        macro_assembler->CheckSpecialCharacterClass(cc->standard_type(),
-                                                    on_failure)) {
+  if (cc->is_standard(zone) &&
+      macro_assembler->CheckSpecialCharacterClass(cc->standard_type(),
+                                                  on_failure)) {
       return;
   }
 
   for (int i = 0; i < last_valid_range; i++) {
     CharacterRange& range = ranges->at(i);
     Label next_range;
     uc16 from = range.from();
     uc16 to = range.to();
     if (from > max_char) {
       continue;
@@ skipping 318 matching lines @@
 //
 // We iterate along the text object, building up for each character a
 // mask and value that can be used to test for a quick failure to match.
 // The masks and values for the positions will be combined into a single
 // machine word for the current character width in order to be used in
 // generating a quick check.
 void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
                                     int characters_filled_in,
                                     bool not_at_start) {
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = compiler->isolate();
   ASSERT(characters_filled_in < details->characters());
   int characters = details->characters();
   int char_mask;
   int char_shift;
   if (compiler->ascii()) {
     char_mask = String::kMaxAsciiCharCode;
     char_shift = 8;
   } else {
     char_mask = String::kMaxUC16CharCode;
     char_shift = 16;
@@ skipping 57 matching lines @@
         characters_filled_in++;
         ASSERT(characters_filled_in <= details->characters());
         if (characters_filled_in == details->characters()) {
           return;
         }
       }
     } else {
       QuickCheckDetails::Position* pos =
           details->positions(characters_filled_in);
       RegExpCharacterClass* tree = elm.data.u_char_class;
-      ZoneList<CharacterRange>* ranges = tree->ranges();
+      ZoneList<CharacterRange>* ranges = tree->ranges(isolate->zone());
       if (tree->is_negated()) {
         // A quick check uses multi-character mask and compare.  There is no
         // useful way to incorporate a negative char class into this scheme
         // so we just conservatively create a mask and value that will always
         // succeed.
         pos->mask = 0;
         pos->value = 0;
       } else {
         int first_range = 0;
         while (ranges->at(first_range).from() > char_mask) {
@@ skipping 433 matching lines @@
 // loading characters, which means we do not need to recheck the bounds
 // up to the limit the quick check already checked.  In addition the quick
 // check can have involved a mask and compare operation which may simplify
 // or obviate the need for further checks at some character positions.
 void TextNode::TextEmitPass(RegExpCompiler* compiler,
                             TextEmitPassType pass,
                             bool preloaded,
                             Trace* trace,
                             bool first_element_checked,
                             int* checked_up_to) {
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = compiler->isolate();
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
   bool ascii = compiler->ascii();
   Label* backtrack = trace->backtrack();
   QuickCheckDetails* quick_check = trace->quick_check_performed();
   int element_count = elms_->length();
   for (int i = preloaded ? 0 : element_count - 1; i >= 0; i--) {
     TextElement elm = elms_->at(i);
     int cp_offset = trace->cp_offset() + elm.cp_offset;
     if (elm.type == TextElement::ATOM) {
       Vector<const uc16> quarks = elm.data.u_atom->data();
@@ skipping 31 matching lines @@
                                              preloaded);
           if (bound_checked) UpdateBoundsCheck(cp_offset + j, checked_up_to);
         }
       }
     } else {
       ASSERT_EQ(elm.type, TextElement::CHAR_CLASS);
       if (pass == CHARACTER_CLASS_MATCH) {
         if (first_element_checked && i == 0) continue;
         if (DeterminedAlready(quick_check, elm.cp_offset)) continue;
         RegExpCharacterClass* cc = elm.data.u_char_class;
-        EmitCharClass(assembler,
+        EmitCharClass(compiler->zone(),
+                      assembler,
                       cc,
                       ascii,
                       backtrack,
                       cp_offset,
                       *checked_up_to < cp_offset,
                       preloaded);
         UpdateBoundsCheck(cp_offset, checked_up_to);
       }
     }
   }
@@ skipping 98 matching lines @@
   quick_check_performed_.Advance(by, compiler->ascii());
   cp_offset_ += by;
   if (cp_offset_ > RegExpMacroAssembler::kMaxCPOffset) {
     compiler->SetRegExpTooBig();
     cp_offset_ = 0;
   }
   bound_checked_up_to_ = Max(0, bound_checked_up_to_ - by);
 }
 
 
-void TextNode::MakeCaseIndependent(bool is_ascii) {
+void TextNode::MakeCaseIndependent(Zone* zone, bool is_ascii) {
   int element_count = elms_->length();
   for (int i = 0; i < element_count; i++) {
     TextElement elm = elms_->at(i);
     if (elm.type == TextElement::CHAR_CLASS) {
       RegExpCharacterClass* cc = elm.data.u_char_class;
       // None of the standard character classses is different in the case
       // independent case and it slows us down if we don't know that.
-      if (cc->is_standard()) continue;
-      ZoneList<CharacterRange>* ranges = cc->ranges();
+      if (cc->is_standard(zone)) continue;
+      ZoneList<CharacterRange>* ranges = cc->ranges(zone);
       int range_count = ranges->length();
       for (int j = 0; j < range_count; j++) {
         ranges->at(j).AddCaseEquivalents(ranges, is_ascii);
       }
     }
   }
 }
 
 
 int TextNode::GreedyLoopTextLength() {
@@ skipping 101 matching lines @@
   bool expects_preload;
   Label after;
   QuickCheckDetails quick_check_details;
 };
 
 
 // Creates a list of AlternativeGenerations.  If the list has a reasonable
 // size then it is on the stack, otherwise the excess is on the heap.
 class AlternativeGenerationList {
  public:
-  explicit AlternativeGenerationList(int count)
-      : alt_gens_(count) {
+  AlternativeGenerationList(Zone* zone, int count)
+      : alt_gens_(zone, count) {
     for (int i = 0; i < count && i < kAFew; i++) {
       alt_gens_.Add(a_few_alt_gens_ + i);
     }
     for (int i = kAFew; i < count; i++) {
       alt_gens_.Add(new AlternativeGeneration());
     }
   }
   ~AlternativeGenerationList() {
     for (int i = kAFew; i < alt_gens_.length(); i++) {
       delete alt_gens_[i];
@@ skipping 155 matching lines @@
 
   int first_normal_choice = greedy_loop ? 1 : 0;
 
   int preload_characters =
       CalculatePreloadCharacters(compiler,
                                  current_trace->at_start() == Trace::FALSE);
   bool preload_is_current =
       (current_trace->characters_preloaded() == preload_characters);
   bool preload_has_checked_bounds = preload_is_current;
 
-  AlternativeGenerationList alt_gens(choice_count);
+  AlternativeGenerationList alt_gens(compiler->zone(), choice_count);
 
   // For now we just call all choices one after the other.  The idea ultimately
   // is to use the Dispatch table to try only the relevant ones.
   for (int i = first_normal_choice; i < choice_count; i++) {
     GuardedAlternative alternative = alternatives_->at(i);
     AlternativeGeneration* alt_gen = alt_gens.at(i);
     alt_gen->quick_check_details.set_characters(preload_characters);
     ZoneList<Guard*>* guards = alternative.guards();
     int guard_count = (guards == NULL) ? 0 : guards->length();
     Trace new_trace(*current_trace);
@@ skipping 439 matching lines @@
   stream()->Add("  a%p -> n%p [style=dashed, color=grey, "
                 "arrowhead=none];\n", that, that);
 }
 
 
 static const bool kPrintDispatchTable = false;
 void DotPrinter::VisitChoice(ChoiceNode* that) {
   if (kPrintDispatchTable) {
     stream()->Add("  n%p [shape=Mrecord, label=\"", that);
     TableEntryHeaderPrinter header_printer(stream());
-    that->GetTable(ignore_case_)->ForEach(&header_printer);
+    that->GetTable(ZONE, ignore_case_)->ForEach(&header_printer);
     stream()->Add("\"]\n", that);
     PrintAttributes(that);
     TableEntryBodyPrinter body_printer(stream(), that);
-    that->GetTable(ignore_case_)->ForEach(&body_printer);
+    that->GetTable(ZONE, ignore_case_)->ForEach(&body_printer);
   } else {
     stream()->Add("  n%p [shape=Mrecord, label=\"?\"];\n", that);
     for (int i = 0; i < that->alternatives()->length(); i++) {
       GuardedAlternative alt = that->alternatives()->at(i);
       stream()->Add("  n%p -> n%p;\n", that, alt.node());
     }
   }
   for (int i = 0; i < that->alternatives()->length(); i++) {
     GuardedAlternative alt = that->alternatives()->at(i);
     alt.node()->Accept(this);
   }
 }
 
 
 void DotPrinter::VisitText(TextNode* that) {
   stream()->Add("  n%p [label=\"", that);
   for (int i = 0; i < that->elements()->length(); i++) {
     if (i > 0) stream()->Add(" ");
     TextElement elm = that->elements()->at(i);
     switch (elm.type) {
       case TextElement::ATOM: {
         stream()->Add("'%w'", elm.data.u_atom->data());
         break;
       }
       case TextElement::CHAR_CLASS: {
         RegExpCharacterClass* node = elm.data.u_char_class;
         stream()->Add("[");
         if (node->is_negated())
           stream()->Add("^");
-        for (int j = 0; j < node->ranges()->length(); j++) {
-          CharacterRange range = node->ranges()->at(j);
+        Zone* zone = ZONE;
+        for (int j = 0; j < node->ranges(zone)->length(); j++) {
+          CharacterRange range = node->ranges(zone)->at(j);
           stream()->Add("%k-%k", range.from(), range.to());
         }
         stream()->Add("]");
         break;
       }
       default:
         UNREACHABLE();
     }
   }
   stream()->Add("\", shape=box, peripheries=2];\n");
@@ skipping 160 matching lines @@
 
 static const int kDigitRangeCount = 2;
 static const uc16 kDigitRanges[kDigitRangeCount] = { '0', '9' };
 
 static const int kLineTerminatorRangeCount = 6;
 static const uc16 kLineTerminatorRanges[kLineTerminatorRangeCount] = { 0x000A,
     0x000A, 0x000D, 0x000D, 0x2028, 0x2029 };
 
 RegExpNode* RegExpAtom::ToNode(RegExpCompiler* compiler,
                                RegExpNode* on_success) {
-  ZoneList<TextElement>* elms = new ZoneList<TextElement>(1);
+  ZoneList<TextElement>* elms = ZoneList<TextElement>::New(compiler->zone(), 1);
   elms->Add(TextElement::Atom(this));
   return new TextNode(elms, on_success);
 }
 
 
 RegExpNode* RegExpText::ToNode(RegExpCompiler* compiler,
                                RegExpNode* on_success) {
   return new TextNode(elements(), on_success);
 }
 
@@ skipping 35 matching lines @@
   for (int i = 0; i < length; i += 2) {
     CharacterRange range = ranges->at(i >> 1);
     if (range.from() != special_class[i] || range.to() != special_class[i+1]) {
       return false;
     }
   }
   return true;
 }
 
 
-bool RegExpCharacterClass::is_standard() {
+bool RegExpCharacterClass::is_standard(Zone* zone) {
   // TODO(lrn): Remove need for this function, by not throwing away information
   // along the way.
   if (is_negated_) {
     return false;
   }
   if (set_.is_standard()) {
     return true;
   }
-  if (CompareRanges(set_.ranges(), kSpaceRanges, kSpaceRangeCount)) {
+  if (CompareRanges(set_.ranges(zone), kSpaceRanges, kSpaceRangeCount)) {
     set_.set_standard_set_type('s');
     return true;
   }
-  if (CompareInverseRanges(set_.ranges(), kSpaceRanges, kSpaceRangeCount)) {
+  if (CompareInverseRanges(set_.ranges(zone), kSpaceRanges, kSpaceRangeCount)) {
     set_.set_standard_set_type('S');
     return true;
   }
-  if (CompareInverseRanges(set_.ranges(),
+  if (CompareInverseRanges(set_.ranges(zone),
                            kLineTerminatorRanges,
                            kLineTerminatorRangeCount)) {
     set_.set_standard_set_type('.');
     return true;
   }
-  if (CompareRanges(set_.ranges(),
+  if (CompareRanges(set_.ranges(zone),
                     kLineTerminatorRanges,
                     kLineTerminatorRangeCount)) {
     set_.set_standard_set_type('n');
     return true;
   }
-  if (CompareRanges(set_.ranges(), kWordRanges, kWordRangeCount)) {
+  if (CompareRanges(set_.ranges(zone), kWordRanges, kWordRangeCount)) {
     set_.set_standard_set_type('w');
     return true;
   }
-  if (CompareInverseRanges(set_.ranges(), kWordRanges, kWordRangeCount)) {
+  if (CompareInverseRanges(set_.ranges(zone), kWordRanges, kWordRangeCount)) {
     set_.set_standard_set_type('W');
     return true;
   }
   return false;
 }
 
 
 RegExpNode* RegExpCharacterClass::ToNode(RegExpCompiler* compiler,
                                          RegExpNode* on_success) {
-  return new TextNode(this, on_success);
+  return new TextNode(compiler->zone(), this, on_success);
 }
 
 
 RegExpNode* RegExpDisjunction::ToNode(RegExpCompiler* compiler,
                                       RegExpNode* on_success) {
   ZoneList<RegExpTree*>* alternatives = this->alternatives();
   int length = alternatives->length();
-  ChoiceNode* result = new ChoiceNode(length);
+  ChoiceNode* result = new ChoiceNode(compiler->zone(), length);
   for (int i = 0; i < length; i++) {
     GuardedAlternative alternative(alternatives->at(i)->ToNode(compiler,
                                                                on_success));
     result->AddAlternative(alternative);
   }
   return result;
 }
 
 
 RegExpNode* RegExpQuantifier::ToNode(RegExpCompiler* compiler,
@@ skipping 102 matching lines @@
         return answer;
       }
     }
     if (max <= kMaxUnrolledMaxMatches && min == 0) {
       ASSERT(max > 0);  // Due to the 'if' above.
       RegExpExpansionLimiter limiter(compiler, max);
       if (limiter.ok_to_expand()) {
         // Unroll the optional matches up to max.
         RegExpNode* answer = on_success;
         for (int i = 0; i < max; i++) {
-          ChoiceNode* alternation = new ChoiceNode(2);
+          ChoiceNode* alternation = new ChoiceNode(compiler->zone(), 2);
           if (is_greedy) {
             alternation->AddAlternative(
                 GuardedAlternative(body->ToNode(compiler, answer)));
             alternation->AddAlternative(GuardedAlternative(on_success));
           } else {
             alternation->AddAlternative(GuardedAlternative(on_success));
             alternation->AddAlternative(
                 GuardedAlternative(body->ToNode(compiler, answer)));
           }
           answer = alternation;
           if (not_at_start) alternation->set_not_at_start();
         }
         return answer;
       }
     }
   }
   bool has_min = min > 0;
   bool has_max = max < RegExpTree::kInfinity;
   bool needs_counter = has_min || has_max;
   int reg_ctr = needs_counter
       ? compiler->AllocateRegister()
       : RegExpCompiler::kNoRegister;
-  LoopChoiceNode* center = new LoopChoiceNode(body->min_match() == 0);
+  LoopChoiceNode* center = new LoopChoiceNode(compiler->zone(),
+                                              body->min_match() == 0);
   if (not_at_start) center->set_not_at_start();
   RegExpNode* loop_return = needs_counter
       ? static_cast<RegExpNode*>(ActionNode::IncrementRegister(reg_ctr, center))
       : static_cast<RegExpNode*>(center);
   if (body_can_be_empty) {
     // If the body can be empty we need to check if it was and then
     // backtrack.
     loop_return = ActionNode::EmptyMatchCheck(body_start_reg,
                                               reg_ctr,
                                               min,
                                               loop_return);
   }
   RegExpNode* body_node = body->ToNode(compiler, loop_return);
   if (body_can_be_empty) {
     // If the body can be empty we need to store the start position
     // so we can bail out if it was empty.
     body_node = ActionNode::StorePosition(body_start_reg, false, body_node);
   }
   if (needs_capture_clearing) {
     // Before entering the body of this loop we need to clear captures.
     body_node = ActionNode::ClearCaptures(capture_registers, body_node);
   }
   GuardedAlternative body_alt(body_node);
   if (has_max) {
     Guard* body_guard = new Guard(reg_ctr, Guard::LT, max);
-    body_alt.AddGuard(body_guard);
+    body_alt.AddGuard(compiler->zone(), body_guard);
   }
   GuardedAlternative rest_alt(on_success);
   if (has_min) {
     Guard* rest_guard = new Guard(reg_ctr, Guard::GEQ, min);
-    rest_alt.AddGuard(rest_guard);
+    rest_alt.AddGuard(compiler->zone(), rest_guard);
   }
   if (is_greedy) {
     center->AddLoopAlternative(body_alt);
     center->AddContinueAlternative(rest_alt);
   } else {
     center->AddContinueAlternative(rest_alt);
     center->AddLoopAlternative(body_alt);
   }
   if (needs_counter) {
     return ActionNode::SetRegister(reg_ctr, 0, center);
@@ skipping 17 matching lines @@
       return AssertionNode::AtNonBoundary(on_success);
     case END_OF_INPUT:
       return AssertionNode::AtEnd(on_success);
     case END_OF_LINE: {
       // Compile $ in multiline regexps as an alternation with a positive
       // lookahead in one side and an end-of-input on the other side.
       // We need two registers for the lookahead.
       int stack_pointer_register = compiler->AllocateRegister();
       int position_register = compiler->AllocateRegister();
       // The ChoiceNode to distinguish between a newline and end-of-input.
-      ChoiceNode* result = new ChoiceNode(2);
+      ChoiceNode* result = new ChoiceNode(compiler->zone(), 2);
       // Create a newline atom.
       ZoneList<CharacterRange>* newline_ranges =
-          new ZoneList<CharacterRange>(3);
+          ZoneList<CharacterRange>::New(compiler->zone(), 3);
       CharacterRange::AddClassEscape('n', newline_ranges);
       RegExpCharacterClass* newline_atom = new RegExpCharacterClass('n');
       TextNode* newline_matcher = new TextNode(
-         newline_atom,
-         ActionNode::PositiveSubmatchSuccess(stack_pointer_register,
-                                             position_register,
-                                             0,  // No captures inside.
-                                             -1,  // Ignored if no captures.
-                                             on_success));
+          compiler->zone(),
+          newline_atom,
+          ActionNode::PositiveSubmatchSuccess(stack_pointer_register,
+                                              position_register,
+                                              0,  // No captures inside.
+                                              -1,  // Ignored if no captures.
+                                              on_success));
       // Create an end-of-input matcher.
       RegExpNode* end_of_line = ActionNode::BeginSubmatch(
           stack_pointer_register,
           position_register,
           newline_matcher);
       // Add the two alternatives to the ChoiceNode.
       GuardedAlternative eol_alternative(end_of_line);
       result->AddAlternative(eol_alternative);
       GuardedAlternative end_alternative(AssertionNode::AtEnd(on_success));
       result->AddAlternative(end_alternative);
@@ skipping 56 matching lines @@
     // ChoiceNode that knows to ignore the first exit when calculating quick
     // checks.
     GuardedAlternative body_alt(
         body()->ToNode(
             compiler,
             success = new NegativeSubmatchSuccess(stack_pointer_register,
                                                   position_register,
                                                   register_count,
                                                   register_start)));
     ChoiceNode* choice_node =
-        new NegativeLookaheadChoiceNode(body_alt,
+        new NegativeLookaheadChoiceNode(compiler->zone(),
+                                        body_alt,
                                         GuardedAlternative(on_success));
     return ActionNode::BeginSubmatch(stack_pointer_register,
                                      position_register,
                                      choice_node);
   }
 }
 
 
 RegExpNode* RegExpCapture::ToNode(RegExpCompiler* compiler,
                                   RegExpNode* on_success) {
@@ skipping 95 matching lines @@
 }
 
 
 Vector<const uc16> CharacterRange::GetWordBounds() {
   return Vector<const uc16>(kWordRanges, kWordRangeCount);
 }
 
 
 class CharacterRangeSplitter {
  public:
-  CharacterRangeSplitter(ZoneList<CharacterRange>** included,
-                          ZoneList<CharacterRange>** excluded)
-      : included_(included),
+  CharacterRangeSplitter(Zone* zone,
+                         ZoneList<CharacterRange>** included,
+                         ZoneList<CharacterRange>** excluded)
+      : zone_(zone),
+        included_(included),
         excluded_(excluded) { }
   void Call(uc16 from, DispatchTable::Entry entry);
 
   static const int kInBase = 0;
   static const int kInOverlay = 1;
 
  private:
+  Zone* zone_;
   ZoneList<CharacterRange>** included_;
   ZoneList<CharacterRange>** excluded_;
 };
 
 
-void CharacterRangeSplitter::Call(uc16 from, DispatchTable::Entry entry) {
+void CharacterRangeSplitter::Call(uc16 from,
+                                  DispatchTable::Entry entry) {
   if (!entry.out_set()->Get(kInBase)) return;
   ZoneList<CharacterRange>** target = entry.out_set()->Get(kInOverlay)
     ? included_
     : excluded_;
-  if (*target == NULL) *target = new ZoneList<CharacterRange>(2);
+  if (*target == NULL) *target = ZoneList<CharacterRange>::New(zone_, 2);
   (*target)->Add(CharacterRange(entry.from(), entry.to()));
 }
 
 
-void CharacterRange::Split(ZoneList<CharacterRange>* base,
+void CharacterRange::Split(Zone* zone,
+                           ZoneList<CharacterRange>* base,
                            Vector<const uc16> overlay,
                            ZoneList<CharacterRange>** included,
                            ZoneList<CharacterRange>** excluded) {
   ASSERT_EQ(NULL, *included);
   ASSERT_EQ(NULL, *excluded);
-  DispatchTable table;
+  DispatchTable table(zone);
   for (int i = 0; i < base->length(); i++)
     table.AddRange(base->at(i), CharacterRangeSplitter::kInBase);
   for (int i = 0; i < overlay.length(); i += 2) {
     table.AddRange(CharacterRange(overlay[i], overlay[i+1]),
                    CharacterRangeSplitter::kInOverlay);
   }
-  CharacterRangeSplitter callback(included, excluded);
+  CharacterRangeSplitter callback(zone, included, excluded);
   table.ForEach(&callback);
 }
 
 
 void CharacterRange::AddCaseEquivalents(ZoneList<CharacterRange>* ranges,
                                         bool is_ascii) {
   Isolate* isolate = Isolate::Current();
   uc16 bottom = from();
   uc16 top = to();
   if (is_ascii) {
@@ skipping 144 matching lines @@
     result.SetElementsInSecondSet();
   } else if (j < range->length()) {
     // Argument range contains something not in word range.
     result.SetElementsInFirstSet();
   }
 
   return result;
 }
 
 
-ZoneList<CharacterRange>* CharacterSet::ranges() {
+ZoneList<CharacterRange>* CharacterSet::ranges(Zone* zone) {
   if (ranges_ == NULL) {
-    ranges_ = new ZoneList<CharacterRange>(2);
+    ranges_ = ZoneList<CharacterRange>::New(zone, 2);
     CharacterRange::AddClassEscape(standard_set_type_, ranges_);
   }
   return ranges_;
 }
 
 
 // Move a number of elements in a zonelist to another position
 // in the same list. Handles overlapping source and target areas.
 static void MoveRanges(ZoneList<CharacterRange>* list,
                        int from,
@@ skipping 285 matching lines @@
 RegExpNode* RegExpNode::TryGetSibling(NodeInfo* info) {
   for (int i = 0; i < siblings_.length(); i++) {
     RegExpNode* sibling = siblings_.Get(i);
     if (sibling->info()->Matches(info))
       return sibling;
   }
   return NULL;
 }
 
 
-RegExpNode* RegExpNode::EnsureSibling(NodeInfo* info, bool* cloned) {
+RegExpNode* RegExpNode::EnsureSibling(Zone* zone,
+                                      NodeInfo* info,
+                                      bool* cloned) {
   ASSERT_EQ(false, *cloned);
-  siblings_.Ensure(this);
+  siblings_.Ensure(zone, this);
   RegExpNode* result = TryGetSibling(info);
   if (result != NULL) return result;
   result = this->Clone();
   NodeInfo* new_info = result->info();
   new_info->ResetCompilationState();
   new_info->AddFromPreceding(info);
   AddSibling(result);
   *cloned = true;
   return result;
 }
 
 
 template <class C>
 static RegExpNode* PropagateToEndpoint(C* node, NodeInfo* info) {
   NodeInfo full_info(*node->info());
   full_info.AddFromPreceding(info);
   bool cloned = false;
   return RegExpNode::EnsureSibling(node, &full_info, &cloned);
 }
 
 
 // -------------------------------------------------------------------
 // Splay tree
 
 
-OutSet* OutSet::Extend(unsigned value) {
+OutSet* OutSet::Extend(Zone* zone, unsigned value) {
   if (Get(value))
     return this;
   if (successors() != NULL) {
     for (int i = 0; i < successors()->length(); i++) {
       OutSet* successor = successors()->at(i);
       if (successor->Get(value))
         return successor;
     }
   } else {
-    successors_ = new ZoneList<OutSet*>(2);
+    successors_ = ZoneList<OutSet*>::New(zone, 2);
   }
-  OutSet* result = new OutSet(first_, remaining_);
-  result->Set(value);
+  OutSet* result = new(zone) OutSet(first_, remaining_);
+  result->Set(zone, value);
   successors()->Add(result);
   return result;
 }
 
 
-void OutSet::Set(unsigned value) {
+void OutSet::Set(Zone* zone, unsigned value) {
   if (value < kFirstLimit) {
     first_ |= (1 << value);
   } else {
     if (remaining_ == NULL)
-      remaining_ = new ZoneList<unsigned>(1);
+      remaining_ = ZoneList<unsigned>::New(zone, 1);
     if (remaining_->is_empty() || !remaining_->Contains(value))
       remaining_->Add(value);
   }
 }
 
 
 bool OutSet::Get(unsigned value) {
   if (value < kFirstLimit) {
     return (first_ & (1 << value)) != 0;
   } else if (remaining_ == NULL) {
     return false;
   } else {
     return remaining_->Contains(value);
   }
 }
 
 
 const uc16 DispatchTable::Config::kNoKey = unibrow::Utf8::kBadChar;
 const DispatchTable::Entry DispatchTable::Config::kNoValue;
 
 
 void DispatchTable::AddRange(CharacterRange full_range, int value) {
   CharacterRange current = full_range;
   if (tree()->is_empty()) {
     // If this is the first range we just insert into the table.
     ZoneSplayTree<Config>::Locator loc;
     ASSERT_RESULT(tree()->Insert(current.from(), &loc));
-    loc.set_value(Entry(current.from(), current.to(), empty()->Extend(value)));
+    loc.set_value(Entry(current.from(),
+                        current.to(),
+                        empty()->Extend(zone_, value)));
     return;
   }
   // First see if there is a range to the left of this one that
   // overlaps.
   ZoneSplayTree<Config>::Locator loc;
   if (tree()->FindGreatestLessThan(current.from(), &loc)) {
     Entry* entry = &loc.value();
     // If we've found a range that overlaps with this one, and it
     // starts strictly to the left of this one, we have to fix it
     // because the following code only handles ranges that start on
@@ skipping 22 matching lines @@
         (loc.value().to() >= current.from())) {
       Entry* entry = &loc.value();
       // We have overlap.  If there is space between the start point of
       // the range we're adding and where the overlapping range starts
       // then we have to add a range covering just that space.
       if (current.from() < entry->from()) {
         ZoneSplayTree<Config>::Locator ins;
         ASSERT_RESULT(tree()->Insert(current.from(), &ins));
         ins.set_value(Entry(current.from(),
                             entry->from() - 1,
-                            empty()->Extend(value)));
+                            empty()->Extend(zone_, value)));
         current.set_from(entry->from());
       }
       ASSERT_EQ(current.from(), entry->from());
       // If the overlapping range extends beyond the one we want to add
       // we have to snap the right part off and add it separately.
       if (entry->to() > current.to()) {
         ZoneSplayTree<Config>::Locator ins;
         ASSERT_RESULT(tree()->Insert(current.to() + 1, &ins));
         ins.set_value(Entry(current.to() + 1,
                             entry->to(),
                             entry->out_set()));
         entry->set_to(current.to());
       }
       ASSERT(entry->to() <= current.to());
       // The overlapping range is now completely contained by the range
       // we're adding so we can just update it and move the start point
       // of the range we're adding just past it.
-      entry->AddValue(value);
+      entry->AddValue(zone_, value);
       // Bail out if the last interval ended at 0xFFFF since otherwise
       // adding 1 will wrap around to 0.
       if (entry->to() == String::kMaxUC16CharCode)
         break;
       ASSERT(entry->to() + 1 > current.from());
       current.set_from(entry->to() + 1);
     } else {
       // There is no overlap so we can just add the range
       ZoneSplayTree<Config>::Locator ins;
       ASSERT_RESULT(tree()->Insert(current.from(), &ins));
       ins.set_value(Entry(current.from(),
                           current.to(),
-                          empty()->Extend(value)));
+                          empty()->Extend(zone_, value)));
       break;
     }
   }
 }
 
 
 OutSet* DispatchTable::Get(uc16 value) {
   ZoneSplayTree<Config>::Locator loc;
   if (!tree()->FindGreatestLessThan(value, &loc))
     return empty();
@@ skipping 42 matching lines @@
     } else {
       cp_offset++;
       Vector<const uc16> quarks = elm.data.u_atom->data();
     }
   }
 }
 
 
 void Analysis::VisitText(TextNode* that) {
   if (ignore_case_) {
-    that->MakeCaseIndependent(is_ascii_);
+    that->MakeCaseIndependent(zone_, is_ascii_);
   }
   EnsureAnalyzed(that->on_success());
   if (!has_failed()) {
     that->CalculateOffsets();
   }
 }
 
 
 void Analysis::VisitAction(ActionNode* that) {
   RegExpNode* target = that->on_success();
@@ skipping 43 matching lines @@
 }
 
 
 void Analysis::VisitAssertion(AssertionNode* that) {
   EnsureAnalyzed(that->on_success());
   AssertionNode::AssertionNodeType type = that->type();
   if (type == AssertionNode::AT_BOUNDARY ||
       type == AssertionNode::AT_NON_BOUNDARY) {
     // Check if the following character is known to be a word character
     // or known to not be a word character.
-    ZoneList<CharacterRange>* following_chars = that->FirstCharacterSet();
+    ZoneList<CharacterRange>* following_chars = that->FirstCharacterSet(zone_);
 
     CharacterRange::Canonicalize(following_chars);
 
     SetRelation word_relation =
         CharacterRange::WordCharacterRelation(following_chars);
     if (word_relation.Disjoint()) {
       // Includes the case where following_chars is empty (e.g., end-of-input).
       // Following character is definitely *not* a word character.
       type = (type == AssertionNode::AT_BOUNDARY) ?
                  AssertionNode::AFTER_WORD_CHARACTER :
                  AssertionNode::AFTER_NONWORD_CHARACTER;
       that->set_type(type);
     } else if (word_relation.ContainedIn()) {
       // Following character is definitely a word character.
       type = (type == AssertionNode::AT_BOUNDARY) ?
                  AssertionNode::AFTER_NONWORD_CHARACTER :
                  AssertionNode::AFTER_WORD_CHARACTER;
       that->set_type(type);
     }
   }
 }
 
 
-ZoneList<CharacterRange>* RegExpNode::FirstCharacterSet() {
+ZoneList<CharacterRange>* RegExpNode::FirstCharacterSet(Zone* zone) {
   if (first_character_set_ == NULL) {
-    if (ComputeFirstCharacterSet(kFirstCharBudget) < 0) {
+    if (ComputeFirstCharacterSet(zone, kFirstCharBudget) < 0) {
       // If we can't find an exact solution within the budget, we
       // set the value to the set of every character, i.e., all characters
       // are possible.
-      ZoneList<CharacterRange>* all_set = new ZoneList<CharacterRange>(1);
+      ZoneList<CharacterRange>* all_set =
+          ZoneList<CharacterRange>::New(zone, 1);
       all_set->Add(CharacterRange::Everything());
       first_character_set_ = all_set;
     }
   }
   return first_character_set_;
 }
 
 
-int RegExpNode::ComputeFirstCharacterSet(int budget) {
+int RegExpNode::ComputeFirstCharacterSet(Zone* zone, int budget) {
   // Default behavior is to not be able to determine the first character.
   return kComputeFirstCharacterSetFail;
 }
 
 
-int LoopChoiceNode::ComputeFirstCharacterSet(int budget) {
+int LoopChoiceNode::ComputeFirstCharacterSet(Zone* zone, int budget) {
   budget--;
   if (budget >= 0) {
     // Find loop min-iteration. It's the value of the guarded choice node
     // with a GEQ guard, if any.
     int min_repetition = 0;
 
     for (int i = 0; i <= 1; i++) {
       GuardedAlternative alternative = alternatives()->at(i);
       ZoneList<Guard*>* guards = alternative.guards();
       if (guards != NULL && guards->length() > 0) {
         Guard* guard = guards->at(0);
         if (guard->op() == Guard::GEQ) {
           min_repetition = guard->value();
           break;
         }
       }
     }
 
-    budget = loop_node()->ComputeFirstCharacterSet(budget);
+    budget = loop_node()->ComputeFirstCharacterSet(zone, budget);
     if (budget >= 0) {
       ZoneList<CharacterRange>* character_set =
           loop_node()->first_character_set();
       if (body_can_be_zero_length() || min_repetition == 0) {
-        budget = continue_node()->ComputeFirstCharacterSet(budget);
+        budget = continue_node()->ComputeFirstCharacterSet(zone, budget);
         if (budget < 0) return budget;
         ZoneList<CharacterRange>* body_set =
             continue_node()->first_character_set();
         ZoneList<CharacterRange>* union_set =
-          new ZoneList<CharacterRange>(Max(character_set->length(),
-                                           body_set->length()));
+            ZoneList<CharacterRange>::New(zone,
+                                          Max(character_set->length(),
+                                              body_set->length()));
         CharacterRange::Merge(character_set,
                               body_set,
                               union_set,
                               union_set,
                               union_set);
         character_set = union_set;
       }
       set_first_character_set(character_set);
     }
   }
   return budget;
 }
 
 
-int NegativeLookaheadChoiceNode::ComputeFirstCharacterSet(int budget) {
+int NegativeLookaheadChoiceNode::ComputeFirstCharacterSet(Zone* zone,
+                                                          int budget) {
   budget--;
   if (budget >= 0) {
     GuardedAlternative successor = this->alternatives()->at(1);
     RegExpNode* successor_node = successor.node();
-    budget = successor_node->ComputeFirstCharacterSet(budget);
+    budget = successor_node->ComputeFirstCharacterSet(zone, budget);
     if (budget >= 0) {
       set_first_character_set(successor_node->first_character_set());
     }
   }
   return budget;
 }
 
 
 // The first character set of an EndNode is unknowable. Just use the
 // default implementation that fails and returns all characters as possible.
 
 
-int AssertionNode::ComputeFirstCharacterSet(int budget) {
+int AssertionNode::ComputeFirstCharacterSet(Zone* zone, int budget) {
   budget -= 1;
   if (budget >= 0) {
     switch (type_) {
       case AT_END: {
-        set_first_character_set(new ZoneList<CharacterRange>(0));
+        set_first_character_set(ZoneList<CharacterRange>::New(zone, 0));
         break;
       }
       case AT_START:
       case AT_BOUNDARY:
       case AT_NON_BOUNDARY:
       case AFTER_NEWLINE:
       case AFTER_NONWORD_CHARACTER:
       case AFTER_WORD_CHARACTER: {
         ASSERT_NOT_NULL(on_success());
-        budget = on_success()->ComputeFirstCharacterSet(budget);
+        budget = on_success()->ComputeFirstCharacterSet(zone, budget);
         if (budget >= 0) {
           set_first_character_set(on_success()->first_character_set());
         }
         break;
       }
     }
   }
   return budget;
 }
 
 
-int ActionNode::ComputeFirstCharacterSet(int budget) {
+int ActionNode::ComputeFirstCharacterSet(Zone* zone, int budget) {
   if (type_ == POSITIVE_SUBMATCH_SUCCESS) return kComputeFirstCharacterSetFail;
   budget--;
   if (budget >= 0) {
     ASSERT_NOT_NULL(on_success());
-    budget = on_success()->ComputeFirstCharacterSet(budget);
+    budget = on_success()->ComputeFirstCharacterSet(zone, budget);
     if (budget >= 0) {
       set_first_character_set(on_success()->first_character_set());
     }
   }
   return budget;
 }
 
 
-int BackReferenceNode::ComputeFirstCharacterSet(int budget) {
+int BackReferenceNode::ComputeFirstCharacterSet(Zone* zone, int budget) {
   // We don't know anything about the first character of a backreference
   // at this point.
   // The potential first characters are the first characters of the capture,
   // and the first characters of the on_success node, depending on whether the
   // capture can be empty and whether it is known to be participating or known
   // not to be.
   return kComputeFirstCharacterSetFail;
 }
 
 
-int TextNode::ComputeFirstCharacterSet(int budget) {
+int TextNode::ComputeFirstCharacterSet(Zone* zone, int budget) {
   budget--;
   if (budget >= 0) {
     ASSERT_NE(0, elements()->length());
     TextElement text = elements()->at(0);
     if (text.type == TextElement::ATOM) {
       RegExpAtom* atom = text.data.u_atom;
       ASSERT_NE(0, atom->length());
       uc16 first_char = atom->data()[0];
-      ZoneList<CharacterRange>* range = new ZoneList<CharacterRange>(1);
+      ZoneList<CharacterRange>* range = ZoneList<CharacterRange>::New(zone, 1);
       range->Add(CharacterRange(first_char, first_char));
       set_first_character_set(range);
     } else {
       ASSERT(text.type == TextElement::CHAR_CLASS);
       RegExpCharacterClass* char_class = text.data.u_char_class;
-      ZoneList<CharacterRange>* ranges = char_class->ranges();
+      ZoneList<CharacterRange>* ranges = char_class->ranges(zone);
       // TODO(lrn): Canonicalize ranges when they are created
       // instead of waiting until now.
       CharacterRange::Canonicalize(ranges);
       if (char_class->is_negated()) {
         int length = ranges->length();
         int new_length = length + 1;
         if (length > 0) {
           if (ranges->at(0).from() == 0) new_length--;
           if (ranges->at(length - 1).to() == String::kMaxUC16CharCode) {
             new_length--;
           }
         }
         ZoneList<CharacterRange>* negated_ranges =
-            new ZoneList<CharacterRange>(new_length);
+            ZoneList<CharacterRange>::New(zone, new_length);
         CharacterRange::Negate(ranges, negated_ranges);
         set_first_character_set(negated_ranges);
       } else {
         set_first_character_set(ranges);
       }
     }
   }
   return budget;
 }
 
@@ skipping 31 matching lines @@
 
 void AddDispatchRange::Call(uc32 from, DispatchTable::Entry entry) {
   CharacterRange range(from, entry.to());
   constructor_->AddRange(range);
 }
 
 
 void DispatchTableConstructor::VisitChoice(ChoiceNode* node) {
   if (node->being_calculated())
     return;
-  DispatchTable* table = node->GetTable(ignore_case_);
+  DispatchTable* table = node->GetTable(zone_, ignore_case_);
   AddDispatchRange adder(this);
   table->ForEach(&adder);
 }
 
 
 void DispatchTableConstructor::VisitBackReference(BackReferenceNode* that) {
   // TODO(160): Find the node that we refer back to and propagate its start
   // set back to here.  For now we just accept anything.
   AddRange(CharacterRange::Everything());
 }
@@ skipping 33 matching lines @@
 void DispatchTableConstructor::VisitText(TextNode* that) {
   TextElement elm = that->elements()->at(0);
   switch (elm.type) {
     case TextElement::ATOM: {
       uc16 c = elm.data.u_atom->data()[0];
       AddRange(CharacterRange(c, c));
       break;
     }
     case TextElement::CHAR_CLASS: {
       RegExpCharacterClass* tree = elm.data.u_char_class;
-      ZoneList<CharacterRange>* ranges = tree->ranges();
+      ZoneList<CharacterRange>* ranges = tree->ranges(zone_);
       if (tree->is_negated()) {
         AddInverse(ranges);
       } else {
         for (int i = 0; i < ranges->length(); i++)
           AddRange(ranges->at(i));
       }
       break;
     }
     default: {
       UNIMPLEMENTED();
     }
   }
 }
 
 
 void DispatchTableConstructor::VisitAction(ActionNode* that) {
   RegExpNode* target = that->on_success();
   target->Accept(this);
 }
 
 
 RegExpEngine::CompilationResult RegExpEngine::Compile(RegExpCompileData* data,
                                                       bool ignore_case,
                                                       bool is_multiline,
                                                       Handle<String> pattern,
                                                       bool is_ascii) {
+  Isolate* isolate = pattern->GetIsolate();
   if ((data->capture_count + 1) * 2 - 1 > RegExpMacroAssembler::kMaxRegister) {
     return IrregexpRegExpTooBig();
   }
-  RegExpCompiler compiler(data->capture_count, ignore_case, is_ascii);
+  RegExpCompiler compiler(isolate, data->capture_count, ignore_case, is_ascii);
   // Wrap the body of the regexp in capture #0.
   RegExpNode* captured_body = RegExpCapture::ToNode(data->tree,
                                                     0,
                                                     &compiler,
                                                     compiler.accept());
   RegExpNode* node = captured_body;
   bool is_end_anchored = data->tree->IsAnchoredAtEnd();
   bool is_start_anchored = data->tree->IsAnchoredAtStart();
   int max_length = data->tree->max_match();
   if (!is_start_anchored) {
     // Add a .*? at the beginning, outside the body capture, unless
     // this expression is anchored at the beginning.
     RegExpNode* loop_node =
         RegExpQuantifier::ToNode(0,
                                  RegExpTree::kInfinity,
                                  false,
                                  new RegExpCharacterClass('*'),
                                  &compiler,
                                  captured_body,
                                  data->contains_anchor);
 
     if (data->contains_anchor) {
       // Unroll loop once, to take care of the case that might start
       // at the start of input.
-      ChoiceNode* first_step_node = new ChoiceNode(2);
+      ChoiceNode* first_step_node = new ChoiceNode(isolate->zone(), 2);
       first_step_node->AddAlternative(GuardedAlternative(captured_body));
       first_step_node->AddAlternative(GuardedAlternative(
-          new TextNode(new RegExpCharacterClass('*'), loop_node)));
+          new TextNode(isolate->zone(),
+                       new RegExpCharacterClass('*'), loop_node)));
       node = first_step_node;
     } else {
       node = loop_node;
     }
   }
   data->node = node;
-  Analysis analysis(ignore_case, is_ascii);
+  Analysis analysis(isolate->zone(), ignore_case, is_ascii);
   analysis.EnsureAnalyzed(node);
   if (analysis.has_failed()) {
     const char* error_message = analysis.error_message();
     return CompilationResult(error_message);
   }
 
   NodeInfo info = *node->info();
 
   // Create the correct assembler for the architecture.
 #ifndef V8_INTERPRETED_REGEXP
@@ skipping 29 matching lines @@
   }
 
   return compiler.Assemble(&macro_assembler,
                            node,
                            data->capture_count,
                            pattern);
 }
 
 
 }}  // namespace v8::internal