Thread/Isolate refactoring: new(Isolate) -> new(Zone)

runtime/vm/regexp.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/regexp.h"
 
 #include "vm/dart_entry.h"
 #include "vm/regexp_assembler.h"
 #include "vm/regexp_ast.h"
 #include "vm/unibrow-inl.h"
 #include "vm/unicode.h"
 #include "vm/symbols.h"
+#include "vm/thread.h"
 
-#define I (isolate())
-#define CI (compiler->isolate())
+#define Z (zone())
+#define CZ (compiler->zone())

[Ivan Posva, 2015/03/13 21:56:50]

I know this is not your code, but please investigate the difference between Z
and CZ, which I find very surprising. Are they pointing to the same zone and
just use different accessors?

[koda, 2015/03/14 00:46:37]

Within this file, Z and CZ always refer to the same zone, which is also the
topmost zone of the thread. (I've verified this manually, but not sure we'd want
to ASSERT this in DEBUG mode, since it is not necessarily needed by the design.)

CZ is used in the visitor-pattern-like ToNode materialization of AST nodes into
actual RegExpNode objects, where the compiler is passed in as an argument,
presumably to avoid paying for an extra zone_ field in every AST node. In most
cases, an available alternative would be to use on_success->zone(), which again
in practice refers to the very same zone.

I'd argue using on_success->zone() is actually more robust, since that makes the
lifetime of the return value of ToNode more obviously consistent, so I've now:

1. changed to on_success->zone()
2. moved the define (now called OZ) closer its first usage
3. added a comment
4. cc'ed zerny@ to verify this makes sense

 
 namespace dart {
 
 DECLARE_FLAG(bool, trace_irregexp);
 
 // Default to generating optimized regexp code.
 static const bool kRegexpOptimization = true;
 
 // More makes code generation slower, less makes V8 benchmark score lower.
 static const intptr_t kMaxLookaheadForBoyerMoore = 8;
@@ skipping 301 matching lines @@
             specialization_cid_ == kExternalOneByteStringCid);
   }
   inline intptr_t specialization_cid() { return specialization_cid_; }
   FrequencyCollator* frequency_collator() { return &frequency_collator_; }
 
   intptr_t current_expansion_factor() { return current_expansion_factor_; }
   void set_current_expansion_factor(intptr_t value) {
     current_expansion_factor_ = value;
   }
 
-  Isolate* isolate() const { return isolate_; }
+  Zone* zone() const { return zone_; }
 
   static const intptr_t kNoRegister = -1;
 
  private:
   EndNode* accept_;
   intptr_t next_register_;
   ZoneGrowableArray<RegExpNode*>* work_list_;
   intptr_t recursion_depth_;
   IRRegExpMacroAssembler* macro_assembler_;
   bool ignore_case_;
   intptr_t specialization_cid_;
   bool reg_exp_too_big_;
   intptr_t current_expansion_factor_;
   FrequencyCollator frequency_collator_;
-  Isolate* isolate_;
+  Zone* zone_;
 };
 
 
 class RecursionCheck : public ValueObject {
  public:
   explicit RecursionCheck(RegExpCompiler* compiler) : compiler_(compiler) {
     compiler->IncrementRecursionDepth();
   }
   ~RecursionCheck() { compiler_->DecrementRecursionDepth(); }
  private:
@@ skipping 10 matching lines @@
 // a fixed array or a null handle depending on whether it succeeded.
 RegExpCompiler::RegExpCompiler(intptr_t capture_count, bool ignore_case,
                                intptr_t specialization_cid)
     : next_register_(2 * (capture_count + 1)),
       work_list_(NULL),
       recursion_depth_(0),
       ignore_case_(ignore_case),
       specialization_cid_(specialization_cid),
       reg_exp_too_big_(false),
       current_expansion_factor_(1),
-      isolate_(Isolate::Current()) {
-  accept_ = new(I) EndNode(EndNode::ACCEPT, I);
+      zone_(Thread::Current()->zone()) {
+  accept_ = new(Z) EndNode(EndNode::ACCEPT, Z);
 }
 
 
 RegExpEngine::CompilationResult RegExpCompiler::Assemble(
     IRRegExpMacroAssembler* macro_assembler,
     RegExpNode* start,
     intptr_t capture_count,
     const String& pattern) {
   static const bool use_slow_safe_regexp_compiler = false;
 
@@ skipping 59 matching lines @@
     }
   }
   return false;
 }
 
 
 // This is called as we come into a loop choice node and some other tricky
 // nodes.  It normalizes the state of the code generator to ensure we can
 // generate generic code.
 intptr_t Trace::FindAffectedRegisters(OutSet* affected_registers,
-                                      Isolate* isolate) {
+                                      Zone* zone) {
   intptr_t max_register = RegExpCompiler::kNoRegister;
   for (DeferredAction* action = actions_;
        action != NULL;
        action = action->next()) {
     if (action->action_type() == ActionNode::CLEAR_CAPTURES) {
       Interval range = static_cast<DeferredClearCaptures*>(action)->range();
       for (intptr_t i = range.from(); i <= range.to(); i++)
-        affected_registers->Set(i, isolate);
+        affected_registers->Set(i, zone);
       if (range.to() > max_register) max_register = range.to();
     } else {
-      affected_registers->Set(action->reg(), isolate);
+      affected_registers->Set(action->reg(), zone);
       if (action->reg() > max_register) max_register = action->reg();
     }
   }
   return max_register;
 }
 
 
 void Trace::RestoreAffectedRegisters(RegExpMacroAssembler* assembler,
                                      intptr_t max_register,
                                      const OutSet& registers_to_pop,
@@ skipping 10 matching lines @@
     }
   }
 }
 
 
 void Trace::PerformDeferredActions(RegExpMacroAssembler* assembler,
                                    intptr_t max_register,
                                    const OutSet& affected_registers,
                                    OutSet* registers_to_pop,
                                    OutSet* registers_to_clear,
-                                   Isolate* isolate) {
+                                   Zone* zone) {
   for (intptr_t reg = 0; reg <= max_register; reg++) {
     if (!affected_registers.Get(reg)) {
       continue;
     }
 
     // The chronologically first deferred action in the trace
     // is used to infer the action needed to restore a register
     // to its previous state (or not, if it's safe to ignore it).
     enum DeferredActionUndoType { ACTION_IGNORE, ACTION_RESTORE, ACTION_CLEAR };
     DeferredActionUndoType undo_action = ACTION_IGNORE;
@@ skipping 71 matching lines @@
           }
           default:
             UNREACHABLE();
             break;
         }
       }
     }
     // Prepare for the undo-action (e.g., push if it's going to be popped).
     if (undo_action == ACTION_RESTORE) {
       assembler->PushRegister(reg);
-      registers_to_pop->Set(reg, isolate);
+      registers_to_pop->Set(reg, zone);
     } else if (undo_action == ACTION_CLEAR) {
-      registers_to_clear->Set(reg, isolate);
+      registers_to_clear->Set(reg, zone);
     }
     // 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();
   }
 
-  intptr_t max_register = FindAffectedRegisters(&affected_registers, CI);
+  intptr_t max_register = FindAffectedRegisters(&affected_registers, CZ);
   OutSet registers_to_pop;
   OutSet registers_to_clear;
   PerformDeferredActions(assembler,
                          max_register,
                          affected_registers,
                          &registers_to_pop,
                          &registers_to_clear,
-                         CI);
+                         CZ);
   if (cp_offset_ != 0) {
     assembler->AdvanceCurrentPosition(cp_offset_);
   }
 
   // Create a new trivial state and generate the node with that.
   BlockLabel undo;
   assembler->PushBacktrack(&undo);
   Trace new_state;
   successor->Emit(compiler, &new_state);
 
@@ skipping 56 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, Isolate* isolate) {
+void GuardedAlternative::AddGuard(Guard* guard, Zone* zone) {
   if (guards_ == NULL)
-    guards_ = new(isolate) ZoneGrowableArray<Guard*>(1);
+    guards_ = new(zone) ZoneGrowableArray<Guard*>(1);
   guards_->Add(guard);
 }
 
 
 ActionNode* ActionNode::SetRegister(intptr_t reg,
                                     intptr_t val,
                                     RegExpNode* on_success) {
   ActionNode* result =
-      new(on_success->isolate()) ActionNode(SET_REGISTER, on_success);
+      new(on_success->zone()) ActionNode(SET_REGISTER, on_success);
   result->data_.u_store_register.reg = reg;
   result->data_.u_store_register.value = val;
   return result;
 }
 
 
 ActionNode* ActionNode::IncrementRegister(intptr_t reg,
                                           RegExpNode* on_success) {
   ActionNode* result =
-      new(on_success->isolate()) ActionNode(INCREMENT_REGISTER, on_success);
+      new(on_success->zone()) ActionNode(INCREMENT_REGISTER, on_success);
   result->data_.u_increment_register.reg = reg;
   return result;
 }
 
 
 ActionNode* ActionNode::StorePosition(intptr_t reg,
                                       bool is_capture,
                                       RegExpNode* on_success) {
   ActionNode* result =
-      new(on_success->isolate()) ActionNode(STORE_POSITION, on_success);
+      new(on_success->zone()) ActionNode(STORE_POSITION, on_success);
   result->data_.u_position_register.reg = reg;
   result->data_.u_position_register.is_capture = is_capture;
   return result;
 }
 
 
 ActionNode* ActionNode::ClearCaptures(Interval range,
                                       RegExpNode* on_success) {
   ActionNode* result =
-      new(on_success->isolate()) ActionNode(CLEAR_CAPTURES, on_success);
+      new(on_success->zone()) ActionNode(CLEAR_CAPTURES, on_success);
   result->data_.u_clear_captures.range_from = range.from();
   result->data_.u_clear_captures.range_to = range.to();
   return result;
 }
 
 
 ActionNode* ActionNode::BeginSubmatch(intptr_t stack_reg,
                                       intptr_t position_reg,
                                       RegExpNode* on_success) {
   ActionNode* result =
-      new(on_success->isolate()) ActionNode(BEGIN_SUBMATCH, on_success);
+      new(on_success->zone()) ActionNode(BEGIN_SUBMATCH, on_success);
   result->data_.u_submatch.stack_pointer_register = stack_reg;
   result->data_.u_submatch.current_position_register = position_reg;
   return result;
 }
 
 
 ActionNode* ActionNode::PositiveSubmatchSuccess(intptr_t stack_reg,
                                                 intptr_t position_reg,
                                                 intptr_t clear_register_count,
                                                 intptr_t clear_register_from,
                                                 RegExpNode* on_success) {
   ActionNode* result =
-      new(on_success->isolate()) ActionNode(POSITIVE_SUBMATCH_SUCCESS,
+      new(on_success->zone()) ActionNode(POSITIVE_SUBMATCH_SUCCESS,
                                             on_success);
   result->data_.u_submatch.stack_pointer_register = stack_reg;
   result->data_.u_submatch.current_position_register = position_reg;
   result->data_.u_submatch.clear_register_count = clear_register_count;
   result->data_.u_submatch.clear_register_from = clear_register_from;
   return result;
 }
 
 
 ActionNode* ActionNode::EmptyMatchCheck(intptr_t start_register,
                                         intptr_t repetition_register,
                                         intptr_t repetition_limit,
                                         RegExpNode* on_success) {
   ActionNode* result =
-      new(on_success->isolate()) ActionNode(EMPTY_MATCH_CHECK, on_success);
+      new(on_success->zone()) ActionNode(EMPTY_MATCH_CHECK, on_success);
   result->data_.u_empty_match_check.start_register = start_register;
   result->data_.u_empty_match_check.repetition_register = repetition_register;
   result->data_.u_empty_match_check.repetition_limit = repetition_limit;
   return result;
 }
 
 
 #define DEFINE_ACCEPT(Type)                                          \
   void Type##Node::Accept(NodeVisitor* visitor) {                    \
     visitor->Visit##Type(this);                                      \
@@ skipping 25 matching lines @@
       ASSERT(!trace->mentions_reg(guard->reg()));
       macro_assembler->IfRegisterLT(guard->reg(),
                                     guard->value(),
                                     trace->backtrack());
       break;
   }
 }
 
 
 // Returns the number of characters in the equivalence class, omitting those
-// that cannot occur in the source string because it is ASCII.
+// that cannot occur in the source string because it is ASCZI.
 static intptr_t GetCaseIndependentLetters(uint16_t character,
                                           bool one_byte_subject,
                                           int32_t* letters) {
   unibrow::Mapping<unibrow::Ecma262UnCanonicalize> jsregexp_uncanonicalize;
   intptr_t length = jsregexp_uncanonicalize.get(character, '\0', letters);
   // Unibrow returns 0 or 1 for characters where case independence is
   // trivial.
   if (length == 0) {
     letters[0] = character;
     length = 1;
   }
   if (!one_byte_subject || character <= Symbols::kMaxOneCharCodeSymbol) {
     return length;
   }
 
-  // The standard requires that non-ASCII characters cannot have ASCII
+  // The standard requires that non-ASCZI characters cannot have ASCZI
   // character codes in their equivalence class.
   // TODO(dcarney): issue 3550 this is not actually true for Latin1 anymore,
   // is it?  For example, \u00C5 is equivalent to \u212B.
   return 0;
 }
 
 
-static inline bool EmitSimpleCharacter(Isolate* isolate,
+static inline bool EmitSimpleCharacter(Zone* zone,
                                        RegExpCompiler* compiler,
                                        uint16_t c,
                                        BlockLabel* on_failure,
                                        intptr_t cp_offset,
                                        bool check,
                                        bool preloaded) {
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
   bool bound_checked = false;
   if (!preloaded) {
     assembler->LoadCurrentCharacter(
         cp_offset,
         on_failure,
         check);
     bound_checked = true;
   }
   assembler->CheckNotCharacter(c, on_failure);
   return bound_checked;
 }
 
 
 // Only emits non-letters (things that don't have case).  Only used for case
 // independent matches.
-static inline bool EmitAtomNonLetter(Isolate* isolate,
+static inline bool EmitAtomNonLetter(Zone* zone,
                                      RegExpCompiler* compiler,
                                      uint16_t c,
                                      BlockLabel* on_failure,
                                      intptr_t cp_offset,
                                      bool check,
                                      bool preloaded) {
   RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
   bool one_byte = compiler->one_byte();
   int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
   intptr_t length = GetCaseIndependentLetters(c, one_byte, chars);
@@ skipping 52 matching lines @@
     macro_assembler->CheckNotCharacterAfterMinusAnd(c1 - diff,
                                                     diff,
                                                     mask,
                                                     on_failure);
     return true;
   }
   return false;
 }
 
 
-typedef bool EmitCharacterFunction(Isolate* isolate,
+typedef bool EmitCharacterFunction(Zone* zone,
                                    RegExpCompiler* compiler,
                                    uint16_t c,
                                    BlockLabel* on_failure,
                                    intptr_t cp_offset,
                                    bool check,
                                    bool preloaded);
 
 // Only emits letters (things that have case).  Only used for case independent
 // matches.
-static inline bool EmitAtomLetter(Isolate* isolate,
+static inline bool EmitAtomLetter(Zone* zone,
                                   RegExpCompiler* compiler,
                                   uint16_t c,
                                   BlockLabel* on_failure,
                                   intptr_t cp_offset,
                                   bool check,
                                   bool preloaded) {
   RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
   bool one_byte = compiler->one_byte();
   int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
   intptr_t length = GetCaseIndependentLetters(c, one_byte, chars);
@@ skipping 118 matching lines @@
     for (j = (ranges->At(i) & kMask); j < (ranges->At(i + 1) & kMask); j++) {
       templ[j] = bit;
     }
     bit ^= 1;
   }
   for (intptr_t i = j; i < kSize; i++) {
     templ[i] = bit;
   }
   // TODO(erikcorry): Cache these.
   const TypedData& ba = TypedData::ZoneHandle(
-        masm->isolate(),
+        masm->zone(),
         TypedData::New(kTypedDataUint8ArrayCid, kSize, Heap::kOld));
   for (intptr_t i = 0; i < kSize; i++) {
     ba.SetUint8(i, templ[i]);
   }
   masm->CheckBitInTable(ba, on_bit_set);
   if (on_bit_clear != fall_through) masm->GoTo(on_bit_clear);
 }
 
 
 static void CutOutRange(RegExpMacroAssembler* masm,
@@ skipping 251 matching lines @@
 }
 
 
 static void EmitCharClass(RegExpMacroAssembler* macro_assembler,
                           RegExpCharacterClass* cc,
                           bool one_byte,
                           BlockLabel* on_failure,
                           intptr_t cp_offset,
                           bool check_offset,
                           bool preloaded,
-                          Isolate* isolate) {
+                          Zone* zone) {
   ZoneGrowableArray<CharacterRange>* ranges = cc->ranges();
   if (!CharacterRange::IsCanonical(ranges)) {
     CharacterRange::Canonicalize(ranges);
   }
 
   intptr_t max_char;
   if (one_byte) {
     max_char = Symbols::kMaxOneCharCodeSymbol;
   } else {
     max_char = Utf16::kMaxCodeUnit;
@@ skipping 53 matching lines @@
   }
 
 
   // A new list with ascending entries.  Each entry is a code unit
   // where there is a boundary between code units that are part of
   // the class and code units that are not.  Normally we insert an
   // entry at zero which goes to the failure label, but if there
   // was already one there we fall through for success on that entry.
   // Subsequent entries have alternating meaning (success/failure).
   ZoneGrowableArray<int>* range_boundaries =
-      new(isolate) ZoneGrowableArray<int>(last_valid_range);
+      new(zone) ZoneGrowableArray<int>(last_valid_range);
 
   bool zeroth_entry_is_failure = !cc->is_negated();
 
   for (intptr_t i = 0; i <= last_valid_range; i++) {
     CharacterRange& range = (*ranges)[i];
     if (range.from() == 0) {
       ASSERT(i == 0);
       zeroth_entry_is_failure = !zeroth_entry_is_failure;
     } else {
       range_boundaries->Add(range.from());
@@ skipping 705 matching lines @@
   }
   if (surviving < 2) return set_replacement(survivor);
 
   set_replacement(this);
   if (surviving == choice_count) {
     return this;
   }
   // Only some of the nodes survived the filtering.  We need to rebuild the
   // alternatives list.
   ZoneGrowableArray<GuardedAlternative>* new_alternatives =
-      new(I) ZoneGrowableArray<GuardedAlternative>(surviving);
+      new(Z) ZoneGrowableArray<GuardedAlternative>(surviving);
   for (intptr_t i = 0; i < choice_count; i++) {
     RegExpNode* replacement =
         (*alternatives_)[i].node()->FilterOneByte(depth - 1, ignore_case);
     if (replacement != NULL) {
       (*alternatives_)[i].set_node(replacement);
       new_alternatives->Add((*alternatives_)[i]);
     }
   }
   alternatives_ = new_alternatives;
   return this;
@@ skipping 141 matching lines @@
   bool not_at_start = (trace->at_start() == Trace::FALSE_VALUE);
   BoyerMooreLookahead* lookahead = bm_info(not_at_start);
   if (lookahead == NULL) {
     intptr_t eats_at_least =
         Utils::Minimum(kMaxLookaheadForBoyerMoore,
                        EatsAtLeast(kMaxLookaheadForBoyerMoore,
                                    kRecursionBudget,
                                    not_at_start));
     if (eats_at_least >= 1) {
       BoyerMooreLookahead* bm =
-          new(I) BoyerMooreLookahead(eats_at_least, compiler, I);
+          new(Z) BoyerMooreLookahead(eats_at_least, compiler, Z);
       FillInBMInfo(0, kRecursionBudget, bm, not_at_start);
       if (bm->at(0)->is_non_word())
         next_is_word_character = Trace::FALSE_VALUE;
       if (bm->at(0)->is_word()) next_is_word_character = Trace::TRUE_VALUE;
     }
   } else {
     if (lookahead->at(0)->is_non_word())
       next_is_word_character = Trace::FALSE_VALUE;
     if (lookahead->at(0)->is_word())
       next_is_word_character = Trace::TRUE_VALUE;
@@ skipping 191 matching lines @@
           case SIMPLE_CHARACTER_MATCH:
             emit_function = &EmitSimpleCharacter;
             break;
           case CASE_CHARACTER_MATCH:
             emit_function = &EmitAtomLetter;
             break;
           default:
             break;
         }
         if (emit_function != NULL) {
-          bool bound_checked = emit_function(I,
+          bool bound_checked = emit_function(Z,
                                              compiler,
                                              quarks->At(j),
                                              backtrack,
                                              cp_offset + j,
                                              *checked_up_to < cp_offset + j,
                                              preloaded);
           if (bound_checked) UpdateBoundsCheck(cp_offset + j, checked_up_to);
         }
       }
     } else {
       ASSERT(elm.text_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.char_class();
         EmitCharClass(assembler,
                       cc,
                       one_byte,
                       backtrack,
                       cp_offset,
                       *checked_up_to < cp_offset,
                       preloaded,
-                      I);
+                      Z);
         UpdateBoundsCheck(cp_offset, checked_up_to);
       }
     }
   }
 }
 
 
 intptr_t TextNode::Length() {
   TextElement elm = elms_->Last();
   ASSERT(elm.cp_offset() >= 0);
@@ skipping 102 matching lines @@
   for (intptr_t i = 0; i < element_count; i++) {
     TextElement elm = elms_->At(i);
     if (elm.text_type() == TextElement::CHAR_CLASS) {
       RegExpCharacterClass* cc = elm.char_class();
       // None of the standard character classes is different in the case
       // independent case and it slows us down if we don't know that.
       if (cc->is_standard()) continue;
       ZoneGrowableArray<CharacterRange>* ranges = cc->ranges();
       intptr_t range_count = ranges->length();
       for (intptr_t j = 0; j < range_count; j++) {
-        (*ranges)[j].AddCaseEquivalents(ranges, is_one_byte, I);
+        (*ranges)[j].AddCaseEquivalents(ranges, is_one_byte, Z);
       }
     }
   }
 }
 
 
 intptr_t TextNode::GreedyLoopTextLength() {
   TextElement elm = elms_->At(elms_->length() - 1);
   return elm.cp_offset() + elm.length();
 }
@@ skipping 210 matching lines @@
 void BoyerMoorePositionInfo::SetAll() {
   s_ = w_ = d_ = kLatticeUnknown;
   if (map_count_ != kMapSize) {
     map_count_ = kMapSize;
     for (intptr_t i = 0; i < kMapSize; i++) (*map_)[i] = true;
   }
 }
 
 
 BoyerMooreLookahead::BoyerMooreLookahead(
-    intptr_t length, RegExpCompiler* compiler, Isolate* isolate)
+    intptr_t length, RegExpCompiler* compiler, Zone* zone)
     : length_(length),
       compiler_(compiler) {
   if (compiler->one_byte()) {
     max_char_ = Symbols::kMaxOneCharCodeSymbol;
   } else {
     max_char_ = Utf16::kMaxCodeUnit;
   }
-  bitmaps_ = new(isolate) ZoneGrowableArray<BoyerMoorePositionInfo*>(length);
+  bitmaps_ = new(zone) ZoneGrowableArray<BoyerMoorePositionInfo*>(length);
   for (intptr_t i = 0; i < length; i++) {
-    bitmaps_->Add(new(isolate) BoyerMoorePositionInfo(isolate));
+    bitmaps_->Add(new(zone) BoyerMoorePositionInfo(zone));
   }
 }
 
 
 // Find the longest range of lookahead that has the fewest number of different
 // characters that can occur at a given position.  Since we are optimizing two
 // different parameters at once this is a tradeoff.
 bool BoyerMooreLookahead::FindWorthwhileInterval(intptr_t* from, intptr_t* to) {
   intptr_t biggest_points = 0;
   // If more than 32 characters out of 128 can occur it is unlikely that we can
@@ skipping 144 matching lines @@
     } else {
       masm->CheckCharacter(single_character, &cont);
     }
     masm->AdvanceCurrentPosition(lookahead_width);
     masm->GoTo(&again);
     masm->BindBlock(&cont);
     return;
   }
 
   const TypedData& boolean_skip_table = TypedData::ZoneHandle(
-        compiler_->isolate(),
+        compiler_->zone(),
         TypedData::New(kTypedDataUint8ArrayCid, kSize, Heap::kOld));
   intptr_t skip_distance = GetSkipTable(
       min_lookahead, max_lookahead, boolean_skip_table);
   ASSERT(skip_distance != 0);
 
   BlockLabel cont, again;
 
   masm->BindBlock(&again);
   masm->LoadCurrentCharacter(max_lookahead, &cont, true);
   masm->CheckBitInTable(boolean_skip_table, &cont);
@@ skipping 268 matching lines @@
   // and step forwards 3 if the character is not one of abc.  Abc need
   // not be atoms, they can be any reasonably limited character class or
   // small alternation.
   BoyerMooreLookahead* bm = bm_info(false);
   if (bm == NULL) {
     eats_at_least = Utils::Minimum(kMaxLookaheadForBoyerMoore,
                         EatsAtLeast(kMaxLookaheadForBoyerMoore,
                                     kRecursionBudget,
                                     false));
     if (eats_at_least >= 1) {
-      bm = new(I) BoyerMooreLookahead(eats_at_least, compiler, I);
+      bm = new(Z) BoyerMooreLookahead(eats_at_least, compiler, Z);
       GuardedAlternative alt0 = alternatives_->At(0);
       alt0.node()->FillInBMInfo(0, kRecursionBudget, bm, false);
     }
   }
   if (bm != NULL) {
     bm->EmitSkipInstructions(macro_assembler);
   }
   return eats_at_least;
 }
 
@@ skipping 520 matching lines @@
 
 #endif  // DEBUG
 
 
 // -------------------------------------------------------------------
 // Tree to graph conversion
 
 RegExpNode* RegExpAtom::ToNode(RegExpCompiler* compiler,
                                RegExpNode* on_success) {
   ZoneGrowableArray<TextElement>* elms =
-      new(CI) ZoneGrowableArray<TextElement>(1);
+      new(CZ) ZoneGrowableArray<TextElement>(1);
   elms->Add(TextElement::Atom(this));
-  return new(CI) TextNode(elms, on_success);
+  return new(CZ) TextNode(elms, on_success);
 }
 
 
 RegExpNode* RegExpText::ToNode(RegExpCompiler* compiler,
                                RegExpNode* on_success) {
   ZoneGrowableArray<TextElement>* elms =
-      new(CI) ZoneGrowableArray<TextElement>(1);
+      new(CZ) ZoneGrowableArray<TextElement>(1);
   for (intptr_t  i = 0; i < elements()->length(); i++) {
     elms->Add(elements()->At(i));
   }
-  return new(CI) TextNode(elms, on_success);
+  return new(CZ) TextNode(elms, on_success);
 }
 
 
 static bool CompareInverseRanges(ZoneGrowableArray<CharacterRange>* ranges,
                                  const intptr_t* special_class,
                                  intptr_t length) {
   length--;  // Remove final 0x10000.
   ASSERT(special_class[length] == 0x10000);
   ASSERT(ranges->length() != 0);
   ASSERT(length != 0);
@@ skipping 76 matching lines @@
   if (CompareInverseRanges(set_.ranges(), kWordRanges, kWordRangeCount)) {
     set_.set_standard_set_type('W');
     return true;
   }
   return false;
 }
 
 
 RegExpNode* RegExpCharacterClass::ToNode(RegExpCompiler* compiler,
                                          RegExpNode* on_success) {
-  return new(CI) TextNode(this, on_success);
+  return new(CZ) TextNode(this, on_success);
 }
 
 
 RegExpNode* RegExpDisjunction::ToNode(RegExpCompiler* compiler,
                                       RegExpNode* on_success) {
   ZoneGrowableArray<RegExpTree*>* alternatives = this->alternatives();
   intptr_t length = alternatives->length();
   ChoiceNode* result =
-      new(CI) ChoiceNode(length, CI);
+      new(CZ) ChoiceNode(length, CZ);
   for (intptr_t 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 74 matching lines @@
   // this case.
   // Unroll (foo)+ and (foo){3,}
   static const intptr_t kMaxUnrolledMinMatches = 3;
   // Unroll (foo)? and (foo){x,3}
   static const intptr_t kMaxUnrolledMaxMatches = 3;
   if (max == 0) return on_success;  // This can happen due to recursion.
   bool body_can_be_empty = (body->min_match() == 0);
   intptr_t body_start_reg = RegExpCompiler::kNoRegister;
   Interval capture_registers = body->CaptureRegisters();
   bool needs_capture_clearing = !capture_registers.is_empty();
-  Isolate* isolate = compiler->isolate();
+  Zone* zone = compiler->zone();
 
   if (body_can_be_empty) {
     body_start_reg = compiler->AllocateRegister();
   } else if (kRegexpOptimization && !needs_capture_clearing) {
     // Only unroll if there are no captures and the body can't be
     // empty.
     {
       RegExpExpansionLimiter limiter(
           compiler, min + ((max != min) ? 1 : 0));
       if (min > 0 && min <= kMaxUnrolledMinMatches && limiter.ok_to_expand()) {
@@ skipping 11 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 (intptr_t i = 0; i < max; i++) {
-          ChoiceNode* alternation = new(isolate) ChoiceNode(2, isolate);
+          ChoiceNode* alternation = new(zone) ChoiceNode(2, zone);
           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;
   intptr_t reg_ctr = needs_counter
       ? compiler->AllocateRegister()
       : RegExpCompiler::kNoRegister;
-  LoopChoiceNode* center = new(isolate) LoopChoiceNode(body->min_match() == 0,
-                                                       isolate);
+  LoopChoiceNode* center = new(zone) LoopChoiceNode(body->min_match() == 0,
+                                                       zone);
   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(isolate) Guard(reg_ctr, Guard::LT, max);
-    body_alt.AddGuard(body_guard, isolate);
+        new(zone) Guard(reg_ctr, Guard::LT, max);
+    body_alt.AddGuard(body_guard, zone);
   }
   GuardedAlternative rest_alt(on_success);
   if (has_min) {
-    Guard* rest_guard = new(isolate) Guard(reg_ctr, Guard::GEQ, min);
-    rest_alt.AddGuard(rest_guard, isolate);
+    Guard* rest_guard = new(zone) Guard(reg_ctr, Guard::GEQ, min);
+    rest_alt.AddGuard(rest_guard, zone);
   }
   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 16 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.
       intptr_t stack_pointer_register = compiler->AllocateRegister();
       intptr_t position_register = compiler->AllocateRegister();
       // The ChoiceNode to distinguish between a newline and end-of-input.
-      ChoiceNode* result = new ChoiceNode(2, on_success->isolate());
+      ChoiceNode* result = new ChoiceNode(2, on_success->zone());
       // Create a newline atom.
       ZoneGrowableArray<CharacterRange>* newline_ranges =
           new ZoneGrowableArray<CharacterRange>(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.
@@ skipping 13 matching lines @@
     }
     default:
       UNREACHABLE();
   }
   return on_success;
 }
 
 
 RegExpNode* RegExpBackReference::ToNode(RegExpCompiler* compiler,
                                         RegExpNode* on_success) {
-  return new(CI)
+  return new(CZ)
       BackReferenceNode(RegExpCapture::StartRegister(index()),
                         RegExpCapture::EndRegister(index()),
                         on_success);
 }
 
 
 RegExpNode* RegExpEmpty::ToNode(RegExpCompiler* compiler,
                                 RegExpNode* on_success) {
   return on_success;
 }
@@ skipping 31 matching lines @@
     // NegativeSubmatchSuccess will unwind the stack including everything the
     // choice node set up and backtrack.  If the first alternative fails then
     // the second alternative is tried, which is exactly the desired result
     // for a negative lookahead.  The NegativeLookaheadChoiceNode is a special
     // ChoiceNode that knows to ignore the first exit when calculating quick
     // checks.
 
     GuardedAlternative body_alt(
         body()->ToNode(
             compiler,
-            success = new(CI) NegativeSubmatchSuccess(stack_pointer_register,
+            success = new(CZ) NegativeSubmatchSuccess(stack_pointer_register,
                                                       position_register,
                                                       register_count,
                                                       register_start,
-                                                      CI)));
+                                                      CZ)));
     ChoiceNode* choice_node =
-        new(CI) NegativeLookaheadChoiceNode(body_alt,
+        new(CZ) NegativeLookaheadChoiceNode(body_alt,
                                             GuardedAlternative(on_success),
-                                            CI);
+                                            CZ);
     return ActionNode::BeginSubmatch(stack_pointer_register,
                                      position_register,
                                      choice_node);
   }
 }
 
 
 RegExpNode* RegExpCapture::ToNode(RegExpCompiler* compiler,
                                   RegExpNode* on_success) {
   return ToNode(body(), index(), compiler, on_success);
@@ skipping 94 matching lines @@
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 void CharacterRange::AddCaseEquivalents(
                         ZoneGrowableArray<CharacterRange>* ranges,
                         bool is_one_byte,
-                        Isolate* isolate) {
+                        Zone* zone) {
   uint16_t bottom = from();
   uint16_t top = to();
   if (is_one_byte && !RangeContainsLatin1Equivalents(*this)) {
     if (bottom > Symbols::kMaxOneCharCodeSymbol) return;
     if (top > Symbols::kMaxOneCharCodeSymbol) {
       top = Symbols::kMaxOneCharCodeSymbol;
     }
   }
 
   unibrow::Mapping<unibrow::Ecma262UnCanonicalize> jsregexp_uncanonicalize;
@@ skipping 233 matching lines @@
                           unsigned value) {
   for (intptr_t i = 0; i < array->length(); i++) {
     if (array->At(i) == value) {
       return true;
     }
   }
   return false;
 }
 
 
-void OutSet::Set(unsigned value, Isolate* isolate) {
+void OutSet::Set(unsigned value, Zone* zone) {
   if (value < kFirstLimit) {
     first_ |= (1 << value);
   } else {
     if (remaining_ == NULL)
-      remaining_ = new(isolate) ZoneGrowableArray<unsigned>(1);
+      remaining_ = new(zone) ZoneGrowableArray<unsigned>(1);
 
     bool remaining_contains_value = ArrayContains(remaining_, value);
     if (remaining_->is_empty() || !remaining_contains_value) {
       remaining_->Add(value);
     }
   }
 }
 
 
 bool OutSet::Get(unsigned value) const {
@@ skipping 198 matching lines @@
                              bm,
                              true);  // Not at start after a text node.
   if (initial_offset == 0) set_bm_info(not_at_start, bm);
 }
 
 
 RegExpEngine::CompilationResult RegExpEngine::Compile(
     RegExpCompileData* data,
     const ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array) {
-  Isolate* isolate = Isolate::Current();
+  Zone* zone = Thread::Current()->zone();
 
   const Function& function = parsed_function->function();
   const intptr_t specialization_cid = function.regexp_cid();
   const bool is_one_byte = (specialization_cid == kOneByteStringCid ||
                             specialization_cid == kExternalOneByteStringCid);
-  JSRegExp& regexp = JSRegExp::Handle(isolate, function.regexp());
-  const String& pattern = String::Handle(isolate, regexp.pattern());
+  JSRegExp& regexp = JSRegExp::Handle(zone, function.regexp());
+  const String& pattern = String::Handle(zone, regexp.pattern());
 
   ASSERT(!regexp.IsNull());
   ASSERT(!pattern.IsNull());
 
   const bool ignore_case = regexp.is_ignore_case();
   const bool is_global = regexp.is_global();
 
   RegExpCompiler compiler(data->capture_count, ignore_case, specialization_cid);
 
   // TODO(zerny): Frequency sampling is currently disabled because of several
@@ skipping 15 matching lines @@
   bool is_end_anchored = data->tree->IsAnchoredAtEnd();
   bool is_start_anchored = data->tree->IsAnchoredAtStart();
   intptr_t 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(isolate) RegExpCharacterClass('*'),
+                                 new(zone) 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(isolate) ChoiceNode(2, isolate);
+      ChoiceNode* first_step_node = new(zone) ChoiceNode(2, zone);
       first_step_node->AddAlternative(GuardedAlternative(captured_body));
       first_step_node->AddAlternative(GuardedAlternative(
-          new(isolate) TextNode(
-              new(isolate) RegExpCharacterClass('*'), loop_node)));
+          new(zone) TextNode(
+              new(zone) RegExpCharacterClass('*'), loop_node)));
       node = first_step_node;
     } else {
       node = loop_node;
     }
   }
   if (is_one_byte) {
     node = node->FilterOneByte(RegExpCompiler::kMaxRecursion, ignore_case);
     // Do it again to propagate the new nodes to places where they were not
     // put because they had not been calculated yet.
     if (node != NULL) {
       node = node->FilterOneByte(RegExpCompiler::kMaxRecursion, ignore_case);
     }
   }
 
-  if (node == NULL) node = new(isolate) EndNode(EndNode::BACKTRACK, isolate);
+  if (node == NULL) node = new(zone) EndNode(EndNode::BACKTRACK, zone);
   data->node = node;
   Analysis analysis(ignore_case, is_one_byte);
   analysis.EnsureAnalyzed(node);
   if (analysis.has_failed()) {
     const char* error_message = analysis.error_message();
     return CompilationResult(error_message);
   }
 
   // Native regexp implementation.
 
   IRRegExpMacroAssembler* macro_assembler =
-      new(isolate) IRRegExpMacroAssembler(specialization_cid,
+      new(zone) IRRegExpMacroAssembler(specialization_cid,
                                           data->capture_count,
                                           parsed_function,
                                           ic_data_array,
-                                          isolate);
+                                          zone);
 
   // Inserted here, instead of in Assembler, because it depends on information
   // in the AST that isn't replicated in the Node structure.
   static const intptr_t kMaxBacksearchLimit = 1024;
   if (is_end_anchored &&
       !is_start_anchored &&
       max_length < kMaxBacksearchLimit) {
     macro_assembler->SetCurrentPositionFromEnd(max_length);
   }
 
@@ skipping 11 matching lines @@
                         pattern);
 
   if (FLAG_trace_irregexp) {
     macro_assembler->PrintBlocks();
   }
 
   return result;
 }
 
 
-static void CreateSpecializedFunction(Isolate* isolate,
+static void CreateSpecializedFunction(Zone* zone,
                                       const JSRegExp& regexp,
                                       intptr_t specialization_cid,
                                       const Object& owner) {
   const intptr_t kParamCount = RegExpMacroAssembler::kParamCount;
 
-  Function& fn = Function::Handle(isolate, Function::New(
+  Function& fn = Function::Handle(zone, Function::New(
       // Append the regexp pattern to the function name.
-      String::Handle(isolate, Symbols::New(
-          String::Handle(isolate, String::Concat(
-              String::Handle(isolate, String::Concat(
+      String::Handle(zone, Symbols::New(
+          String::Handle(zone, String::Concat(
+              String::Handle(zone, String::Concat(
                   Symbols::Irregexp(),
                   Symbols::ColonSpace(), Heap::kOld)),
               String::Handle(regexp.pattern()), Heap::kOld)))),
       RawFunction::kIrregexpFunction,
       true,  // Static.
       false,  // Not const.
       false,  // Not abstract.
       false,  // Not external.
       false,  // Not native.
       owner,
       0));  // No token position.
 
   // TODO(zerny): Share these arrays between all irregexp functions.
   fn.set_num_fixed_parameters(kParamCount);
-  fn.set_parameter_types(Array::Handle(isolate, Array::New(kParamCount,
+  fn.set_parameter_types(Array::Handle(zone, Array::New(kParamCount,
                                                            Heap::kOld)));
-  fn.set_parameter_names(Array::Handle(isolate, Array::New(kParamCount,
+  fn.set_parameter_names(Array::Handle(zone, Array::New(kParamCount,
                                                            Heap::kOld)));
-  fn.SetParameterTypeAt(0, Type::Handle(isolate, Type::DynamicType()));
+  fn.SetParameterTypeAt(0, Type::Handle(zone, Type::DynamicType()));
   fn.SetParameterNameAt(0, Symbols::string_param());
-  fn.SetParameterTypeAt(1, Type::Handle(isolate, Type::DynamicType()));
+  fn.SetParameterTypeAt(1, Type::Handle(zone, Type::DynamicType()));
   fn.SetParameterNameAt(1, Symbols::start_index_param());
-  fn.set_result_type(Type::Handle(isolate, Type::ArrayType()));
+  fn.set_result_type(Type::Handle(zone, Type::ArrayType()));
 
   // Cache the result.
   regexp.set_function(specialization_cid, fn);
 
   fn.set_regexp(regexp);
   fn.set_regexp_cid(specialization_cid);
   fn.set_is_debuggable(false);
 
   // The function is compiled lazily during the first call.
 }
 
 
-RawJSRegExp* RegExpEngine::CreateJSRegExp(Isolate* isolate,
+RawJSRegExp* RegExpEngine::CreateJSRegExp(Zone* zone,
                                           const String& pattern,
                                           bool multi_line,
                                           bool ignore_case) {
   const JSRegExp& regexp = JSRegExp::Handle(JSRegExp::New(0));
 
   regexp.set_pattern(pattern);
 
   if (multi_line) {
     regexp.set_is_multi_line();
   }
   if (ignore_case) {
     regexp.set_is_ignore_case();
   }
 
   // TODO(zerny): We might want to use normal string searching algorithms
   // for simple patterns.
   regexp.set_is_complex();
   regexp.set_is_global();   // All dart regexps are global.
 
-  const Library& lib = Library::Handle(isolate, Library::CoreLibrary());
+  const Library& lib = Library::Handle(zone, Library::CoreLibrary());
   const Class& owner = Class::Handle(
-      isolate, lib.LookupClass(Symbols::RegExp()));
+      zone, lib.LookupClass(Symbols::RegExp()));
 
-  CreateSpecializedFunction(isolate, regexp, kOneByteStringCid, owner);
-  CreateSpecializedFunction(isolate, regexp, kTwoByteStringCid, owner);
-  CreateSpecializedFunction(isolate, regexp, kExternalOneByteStringCid, owner);
-  CreateSpecializedFunction(isolate, regexp, kExternalTwoByteStringCid, owner);
+  CreateSpecializedFunction(zone, regexp, kOneByteStringCid, owner);
+  CreateSpecializedFunction(zone, regexp, kTwoByteStringCid, owner);
+  CreateSpecializedFunction(zone, regexp, kExternalOneByteStringCid, owner);
+  CreateSpecializedFunction(zone, regexp, kExternalTwoByteStringCid, owner);
 
   return regexp.raw();
 }
 
 
 }  // namespace dart