Integrate the Irregexp Regular Expression Engine.

runtime/vm/regexp.cc

Index: runtime/vm/regexp.cc
diff --git a/runtime/vm/regexp.cc b/runtime/vm/regexp.cc
index 534e0c5072dc380457539422f1121bdecd81b0a8..467621b0e53002c03933159d60a54d953ceaaccc 100644
--- a/runtime/vm/regexp.cc
+++ b/runtime/vm/regexp.cc
@@ -4,29 +4,66 @@
 
 #include "vm/regexp.h"
 
-// SNIP
+#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"
+
+#define I (isolate())
+#define CI (compiler->isolate())
 
 namespace dart {
 
-// SNIP
+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;
+
+ContainedInLattice AddRange(ContainedInLattice containment,
+                            const intptr_t* ranges,
+                            intptr_t ranges_length,
+                            Interval new_range) {
+  ASSERT((ranges_length & 1) == 1);
+  ASSERT(ranges[ranges_length - 1] == Utf16::kMaxCodeUnit + 1);
+  if (containment == kLatticeUnknown) return containment;
+  bool inside = false;
+  intptr_t last = 0;
+  for (intptr_t i = 0; i < ranges_length;
+       inside = !inside, last = ranges[i], i++) {
+    // Consider the range from last to ranges[i].
+    // We haven't got to the new range yet.
+    if (ranges[i] <= new_range.from()) continue;
+    // New range is wholly inside last-ranges[i].  Note that new_range.to() is
+    // inclusive, but the values in ranges are not.
+    if (last <= new_range.from() && new_range.to() < ranges[i]) {
+      return Combine(containment, inside ? kLatticeIn : kLatticeOut);
+    }
+    return kLatticeUnknown;
+  }
+  return containment;
+}
 
 // -------------------------------------------------------------------
 // Implementation of the Irregexp regular expression engine.
 //
 // The Irregexp regular expression engine is intended to be a complete
-// implementation of ECMAScript regular expressions.  It generates either
-// bytecodes or native code.
+// implementation of ECMAScript regular expressions.  It generates
+// IR code that is subsequently compiled to native code.
 
 //   The Irregexp regexp engine is structured in three steps.
-//   1) The parser generates an abstract syntax tree.  See ast.cc.
+//   1) The parser generates an abstract syntax tree.  See regexp_ast.cc.
 //   2) From the AST a node network is created.  The nodes are all
 //      subclasses of RegExpNode.  The nodes represent states when
 //      executing a regular expression.  Several optimizations are
 //      performed on the node network.
-//   3) From the nodes we generate either byte codes or native code
-//      that can actually execute the regular expression (perform
-//      the search).  The code generation step is described in more
-//      detail below.
+//   3) From the nodes we generate IR instructions that can actually
+//      execute the regular expression (perform the search).  The
+//      code generation step is described in more detail below.
 
 // Code generation.
 //
@@ -49,8 +86,8 @@ namespace dart {
 //        These are used to implement the actions required on finding
 //        a successful match or failing to find a match.
 //
-//   The code generated (whether as byte codes or native code) maintains
-//   some state as it runs.  This consists of the following elements:
+//   The code generated maintains some state as it runs.  This consists of the
+//   following elements:
 //
 //   * The capture registers.  Used for string captures.
 //   * Other registers.  Used for counters etc.
@@ -160,24 +197,24 @@ namespace dart {
 //   the event that code generation is requested for an identical trace.
 
 
-void RegExpTree::AppendToText(RegExpText* text, Zone* zone) {
+void RegExpTree::AppendToText(RegExpText* text) {
   UNREACHABLE();
 }
 
 
-void RegExpAtom::AppendToText(RegExpText* text, Zone* zone) {
-  text->AddElement(TextElement::Atom(this), zone);
+void RegExpAtom::AppendToText(RegExpText* text) {
+  text->AddElement(TextElement::Atom(this));
 }
 
 
-void RegExpCharacterClass::AppendToText(RegExpText* text, Zone* zone) {
-  text->AddElement(TextElement::CharClass(this), zone);
+void RegExpCharacterClass::AppendToText(RegExpText* text) {
+  text->AddElement(TextElement::CharClass(this));
 }
 
 
-void RegExpText::AppendToText(RegExpText* text, Zone* zone) {
-  for (int i = 0; i < elements()->length(); i++)
-    text->AddElement(elements()->at(i), zone);
+void RegExpText::AppendToText(RegExpText* text) {
+  for (intptr_t i = 0; i < elements()->length(); i++)
+    text->AddElement((*elements())[i]);
 }
 
 
@@ -191,7 +228,7 @@ TextElement TextElement::CharClass(RegExpCharacterClass* char_class) {
 }
 
 
-int TextElement::length() const {
+intptr_t TextElement::length() const {
   switch (text_type()) {
     case ATOM:
       return atom()->length();
@@ -204,36 +241,26 @@ int TextElement::length() const {
 }
 
 
-DispatchTable* ChoiceNode::GetTable(bool ignore_case) {
-  if (table_ == NULL) {
-    table_ = new(zone()) DispatchTable(zone());
-    DispatchTableConstructor cons(table_, ignore_case, zone());
-    cons.BuildTable(this);
-  }
-  return table_;
-}
-
-
-class FrequencyCollator {
+class FrequencyCollator : public ValueObject {
  public:
   FrequencyCollator() : total_samples_(0) {
-    for (int i = 0; i < RegExpMacroAssembler::kTableSize; i++) {
+    for (intptr_t i = 0; i < RegExpMacroAssembler::kTableSize; i++) {
       frequencies_[i] = CharacterFrequency(i);
     }
   }
 
-  void CountCharacter(int character) {
-    int index = (character & RegExpMacroAssembler::kTableMask);
+  void CountCharacter(intptr_t character) {
+    intptr_t index = (character & RegExpMacroAssembler::kTableMask);
     frequencies_[index].Increment();
     total_samples_++;
   }
 
   // Does not measure in percent, but rather per-128 (the table size from the
   // regexp macro assembler).
-  int Frequency(int in_character) {
-    DCHECK((in_character & RegExpMacroAssembler::kTableMask) == in_character);
+  intptr_t Frequency(intptr_t in_character) {
+    ASSERT((in_character & RegExpMacroAssembler::kTableMask) == in_character);
     if (total_samples_ < 1) return 1;  // Division by zero.
-    int freq_in_per128 =
+    intptr_t freq_in_per128 =
         (frequencies_[in_character].counter() * 128) / total_samples_;
     return freq_in_per128;
   }
@@ -242,88 +269,91 @@ class FrequencyCollator {
   class CharacterFrequency {
    public:
     CharacterFrequency() : counter_(0), character_(-1) { }
-    explicit CharacterFrequency(int character)
+    explicit CharacterFrequency(intptr_t character)
         : counter_(0), character_(character) { }
 
     void Increment() { counter_++; }
-    int counter() { return counter_; }
-    int character() { return character_; }
+    intptr_t counter() { return counter_; }
+    intptr_t character() { return character_; }
 
    private:
-    int counter_;
-    int character_;
+    intptr_t counter_;
+    intptr_t character_;
+
+    DISALLOW_ALLOCATION();
   };
 
 
  private:
   CharacterFrequency frequencies_[RegExpMacroAssembler::kTableSize];
-  int total_samples_;
+  intptr_t total_samples_;
 };
 
 
-class RegExpCompiler {
+class RegExpCompiler : public ValueObject {
  public:
-  RegExpCompiler(int capture_count, bool ignore_case, bool is_one_byte,
-                 Zone* zone);
+  RegExpCompiler(intptr_t capture_count,
+                 bool ignore_case,
+                 intptr_t specialization_cid);
 
-  int AllocateRegister() {
-    if (next_register_ >= RegExpMacroAssembler::kMaxRegister) {
-      reg_exp_too_big_ = true;
-      return next_register_;
-    }
+  intptr_t AllocateRegister() {
     return next_register_++;
   }
 
-  RegExpEngine::CompilationResult Assemble(RegExpMacroAssembler* assembler,
+  RegExpEngine::CompilationResult Assemble(IRRegExpMacroAssembler* assembler,
                                            RegExpNode* start,
-                                           int capture_count,
-                                           Handle<String> pattern);
+                                           intptr_t capture_count,
+                                           const String& pattern);
 
   inline void AddWork(RegExpNode* node) { work_list_->Add(node); }
 
-  static const int kImplementationOffset = 0;
-  static const int kNumberOfRegistersOffset = 0;
-  static const int kCodeOffset = 1;
+  static const intptr_t kImplementationOffset = 0;
+  static const intptr_t kNumberOfRegistersOffset = 0;
+  static const intptr_t kCodeOffset = 1;
 
-  RegExpMacroAssembler* macro_assembler() { return macro_assembler_; }
+  IRRegExpMacroAssembler* macro_assembler() { return macro_assembler_; }
   EndNode* accept() { return accept_; }
 
-  static const int kMaxRecursion = 100;
-  inline int recursion_depth() { return recursion_depth_; }
+  static const intptr_t kMaxRecursion = 100;
+  inline intptr_t recursion_depth() { return recursion_depth_; }
   inline void IncrementRecursionDepth() { recursion_depth_++; }
   inline void DecrementRecursionDepth() { recursion_depth_--; }
 
   void SetRegExpTooBig() { reg_exp_too_big_ = true; }
 
   inline bool ignore_case() { return ignore_case_; }
-  inline bool one_byte() { return one_byte_; }
+  inline bool one_byte() const {
+    return (specialization_cid_ == kOneByteStringCid ||
+            specialization_cid_ == kExternalOneByteStringCid);
+  }
+  inline intptr_t specialization_cid() { return specialization_cid_; }
   FrequencyCollator* frequency_collator() { return &frequency_collator_; }
 
-  int current_expansion_factor() { return current_expansion_factor_; }
-  void set_current_expansion_factor(int value) {
+  intptr_t current_expansion_factor() { return current_expansion_factor_; }
+  void set_current_expansion_factor(intptr_t value) {
     current_expansion_factor_ = value;
   }
 
-  Zone* zone() const { return zone_; }
+  Isolate* isolate() const { return isolate_; }
 
-  static const int kNoRegister = -1;
+  static const intptr_t kNoRegister = -1;
 
  private:
   EndNode* accept_;
-  int next_register_;
-  List<RegExpNode*>* work_list_;
-  int recursion_depth_;
-  RegExpMacroAssembler* macro_assembler_;
+  intptr_t next_register_;
+  ZoneGrowableArray<RegExpNode*>* work_list_;
+  intptr_t recursion_depth_;
+  IRRegExpMacroAssembler* macro_assembler_;
   bool ignore_case_;
-  bool one_byte_;
+  intptr_t specialization_cid_;
   bool reg_exp_too_big_;
-  int current_expansion_factor_;
+  intptr_t current_expansion_factor_;
   FrequencyCollator frequency_collator_;
-  Zone* zone_;
+  Isolate* isolate_;
 };
 
 
-class RecursionCheck {
+class RecursionCheck : public ValueObject {
  public:
   explicit RecursionCheck(RegExpCompiler* compiler) : compiler_(compiler) {
     compiler->IncrementRecursionDepth();
@@ -334,84 +364,60 @@ class RecursionCheck {
 };
 
 
-static RegExpEngine::CompilationResult IrregexpRegExpTooBig(Isolate* isolate) {
-  return RegExpEngine::CompilationResult(isolate, "RegExp too big");
+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 one_byte, Zone* zone)
+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),
-      one_byte_(one_byte),
+      specialization_cid_(specialization_cid),
       reg_exp_too_big_(false),
       current_expansion_factor_(1),
-      frequency_collator_(),
-      zone_(zone) {
-  accept_ = new(zone) EndNode(EndNode::ACCEPT, zone);
-  DCHECK(next_register_ - 1 <= RegExpMacroAssembler::kMaxRegister);
+      isolate_(Isolate::Current()) {
+  accept_ = new(I) EndNode(EndNode::ACCEPT, I);
 }
 
 
 RegExpEngine::CompilationResult RegExpCompiler::Assemble(
-    RegExpMacroAssembler* macro_assembler,
+    IRRegExpMacroAssembler* macro_assembler,
     RegExpNode* start,
-    int capture_count,
-    Handle<String> pattern) {
-  Heap* heap = pattern->GetHeap();
-
-  bool use_slow_safe_regexp_compiler = false;
-  if (heap->total_regexp_code_generated() >
-          RegExpImpl::kRegWxpCompiledLimit &&
-      heap->isolate()->memory_allocator()->SizeExecutable() >
-          RegExpImpl::kRegExpExecutableMemoryLimit) {
-    use_slow_safe_regexp_compiler = true;
-  }
+    intptr_t capture_count,
+    const String& pattern) {
+  static const bool use_slow_safe_regexp_compiler = false;
 
   macro_assembler->set_slow_safe(use_slow_safe_regexp_compiler);
+  macro_assembler_ = macro_assembler;
 
-#ifdef DEBUG
-  if (FLAG_trace_regexp_assembler)
-    macro_assembler_ = new RegExpMacroAssemblerTracer(macro_assembler);
-  else
-#endif
-    macro_assembler_ = macro_assembler;
-
-  List <RegExpNode*> work_list(0);
+  ZoneGrowableArray<RegExpNode*> work_list(0);
   work_list_ = &work_list;
-  Label fail;
+  BlockLabel fail;
   macro_assembler_->PushBacktrack(&fail);
   Trace new_trace;
   start->Emit(this, &new_trace);
-  macro_assembler_->Bind(&fail);
+  macro_assembler_->BindBlock(&fail);
   macro_assembler_->Fail();
   while (!work_list.is_empty()) {
     work_list.RemoveLast()->Emit(this, &new_trace);
   }
-  if (reg_exp_too_big_) return IrregexpRegExpTooBig(zone_->isolate());
+  if (reg_exp_too_big_) return IrregexpRegExpTooBig();
 
-  Handle<HeapObject> code = macro_assembler_->GetCode(pattern);
-  heap->IncreaseTotalRegexpCodeGenerated(code->Size());
-  work_list_ = NULL;
-#ifdef DEBUG
-  if (FLAG_print_code) {
-    CodeTracer::Scope trace_scope(heap->isolate()->GetCodeTracer());
-    OFStream os(trace_scope.file());
-    Handle<Code>::cast(code)->Disassemble(pattern->ToCString().get(), os);
-  }
-  if (FLAG_trace_regexp_assembler) {
-    delete macro_assembler_;
-  }
-#endif
-  return RegExpEngine::CompilationResult(*code, next_register_);
+  macro_assembler->FinalizeIndirectGotos();
+
+  return RegExpEngine::CompilationResult(macro_assembler,
+                                         macro_assembler->graph_entry(),
+                                         macro_assembler->num_blocks(),
+                                         macro_assembler->num_stack_locals());
 }
 
 
-bool Trace::DeferredAction::Mentions(int that) {
+bool Trace::DeferredAction::Mentions(intptr_t that) {
   if (action_type() == ActionNode::CLEAR_CAPTURES) {
     Interval range = static_cast<DeferredClearCaptures*>(this)->range();
     return range.Contains(that);
@@ -421,7 +427,7 @@ bool Trace::DeferredAction::Mentions(int that) {
 }
 
 
-bool Trace::mentions_reg(int reg) {
+bool Trace::mentions_reg(intptr_t reg) {
   for (DeferredAction* action = actions_;
        action != NULL;
        action = action->next()) {
@@ -432,8 +438,8 @@ bool Trace::mentions_reg(int reg) {
 }
 
 
-bool Trace::GetStoredPosition(int reg, int* cp_offset) {
-  DCHECK_EQ(0, *cp_offset);
+bool Trace::GetStoredPosition(intptr_t reg, intptr_t* cp_offset) {
+  ASSERT(*cp_offset == 0);
   for (DeferredAction* action = actions_;
        action != NULL;
        action = action->next()) {
@@ -450,19 +456,22 @@ bool Trace::GetStoredPosition(int reg, int* cp_offset) {
 }
 
 
-int Trace::FindAffectedRegisters(OutSet* affected_registers,
-                                 Zone* zone) {
-  int max_register = RegExpCompiler::kNoRegister;
+// 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) {
+  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 (int i = range.from(); i <= range.to(); i++)
-        affected_registers->Set(i, zone);
+      for (intptr_t i = range.from(); i <= range.to(); i++)
+        affected_registers->Set(i, isolate);
       if (range.to() > max_register) max_register = range.to();
     } else {
-      affected_registers->Set(action->reg(), zone);
+      affected_registers->Set(action->reg(), isolate);
       if (action->reg() > max_register) max_register = action->reg();
     }
   }
@@ -471,14 +480,14 @@ int Trace::FindAffectedRegisters(OutSet* affected_registers,
 
 
 void Trace::RestoreAffectedRegisters(RegExpMacroAssembler* assembler,
-                                     int max_register,
+                                     intptr_t max_register,
                                      const OutSet& registers_to_pop,
                                      const OutSet& registers_to_clear) {
-  for (int reg = max_register; reg >= 0; reg--) {
+  for (intptr_t 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;
+      intptr_t clear_to = reg;
       while (reg > 0 && registers_to_clear.Get(reg - 1)) {
         reg--;
       }
@@ -489,18 +498,12 @@ void Trace::RestoreAffectedRegisters(RegExpMacroAssembler* assembler,
 
 
 void Trace::PerformDeferredActions(RegExpMacroAssembler* assembler,
-                                   int max_register,
+                                   intptr_t max_register,
                                    const OutSet& affected_registers,
                                    OutSet* registers_to_pop,
                                    OutSet* registers_to_clear,
-                                   Zone* zone) {
-  // 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;
-
-  for (int reg = 0; reg <= max_register; reg++) {
+                                   Isolate* isolate) {
+  for (intptr_t reg = 0; reg <= max_register; reg++) {
     if (!affected_registers.Get(reg)) {
       continue;
     }
@@ -511,10 +514,10 @@ void Trace::PerformDeferredActions(RegExpMacroAssembler* assembler,
     enum DeferredActionUndoType { IGNORE, RESTORE, CLEAR };
     DeferredActionUndoType undo_action = IGNORE;
 
-    int value = 0;
+    intptr_t value = 0;
     bool absolute = false;
     bool clear = false;
-    int store_position = -1;
+    intptr_t store_position = -1;
     // This is a little tricky because we are scanning the actions in reverse
     // historical order (newest first).
     for (DeferredAction* action = actions_;
@@ -535,16 +538,16 @@ void Trace::PerformDeferredActions(RegExpMacroAssembler* assembler,
             // we can set undo_action to IGNORE if we know there is no value to
             // restore.
             undo_action = RESTORE;
-            DCHECK_EQ(store_position, -1);
-            DCHECK(!clear);
+            ASSERT(store_position == -1);
+            ASSERT(!clear);
             break;
           }
           case ActionNode::INCREMENT_REGISTER:
             if (!absolute) {
               value++;
             }
-            DCHECK_EQ(store_position, -1);
-            DCHECK(!clear);
+            ASSERT(store_position == -1);
+            ASSERT(!clear);
             undo_action = RESTORE;
             break;
           case ActionNode::STORE_POSITION: {
@@ -566,8 +569,8 @@ void Trace::PerformDeferredActions(RegExpMacroAssembler* assembler,
             } else {
               undo_action = pc->is_capture() ? CLEAR : RESTORE;
             }
-            DCHECK(!absolute);
-            DCHECK_EQ(value, 0);
+            ASSERT(!absolute);
+            ASSERT(value == 0);
             break;
           }
           case ActionNode::CLEAR_CAPTURES: {
@@ -578,8 +581,8 @@ void Trace::PerformDeferredActions(RegExpMacroAssembler* assembler,
               clear = true;
             }
             undo_action = RESTORE;
-            DCHECK(!absolute);
-            DCHECK_EQ(value, 0);
+            ASSERT(!absolute);
+            ASSERT(value == 0);
             break;
           }
           default:
@@ -590,18 +593,10 @@ void Trace::PerformDeferredActions(RegExpMacroAssembler* assembler,
     }
     // Prepare for the undo-action (e.g., push if it's going to be popped).
     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, zone);
+      assembler->PushRegister(reg);
+      registers_to_pop->Set(reg, isolate);
     } else if (undo_action == CLEAR) {
-      registers_to_clear->Set(reg, zone);
+      registers_to_clear->Set(reg, isolate);
     }
     // Perform the chronologically last action (or accumulated increment)
     // for the register.
@@ -624,7 +619,7 @@ void Trace::PerformDeferredActions(RegExpMacroAssembler* assembler,
 void Trace::Flush(RegExpCompiler* compiler, RegExpNode* successor) {
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
 
-  DCHECK(!is_trivial());
+  ASSERT(!is_trivial());
 
   if (actions_ == NULL && backtrack() == NULL) {
     // Here we just have some deferred cp advances to fix and we are back to
@@ -647,8 +642,7 @@ void Trace::Flush(RegExpCompiler* compiler, RegExpNode* successor) {
     assembler->PushCurrentPosition();
   }
 
-  int max_register = FindAffectedRegisters(&affected_registers,
-                                           compiler->zone());
+  intptr_t max_register = FindAffectedRegisters(&affected_registers, CI);
   OutSet registers_to_pop;
   OutSet registers_to_clear;
   PerformDeferredActions(assembler,
@@ -656,19 +650,19 @@ void Trace::Flush(RegExpCompiler* compiler, RegExpNode* successor) {
                          affected_registers,
                          &registers_to_pop,
                          &registers_to_clear,
-                         compiler->zone());
+                         CI);
   if (cp_offset_ != 0) {
     assembler->AdvanceCurrentPosition(cp_offset_);
   }
 
   // Create a new trivial state and generate the node with that.
-  Label undo;
+  BlockLabel undo;
   assembler->PushBacktrack(&undo);
   Trace new_state;
   successor->Emit(compiler, &new_state);
 
   // On backtrack we need to restore state.
-  assembler->Bind(&undo);
+  assembler->BindBlock(&undo);
   RestoreAffectedRegisters(assembler,
                            max_register,
                            registers_to_pop,
@@ -687,10 +681,10 @@ void NegativeSubmatchSuccess::Emit(RegExpCompiler* compiler, Trace* trace) {
 
   // Omit flushing the trace. We discard the entire stack frame anyway.
 
-  if (!label()->is_bound()) {
+  if (!label()->IsBound()) {
     // We are completely independent of the trace, since we ignore it,
     // so this code can be used as the generic version.
-    assembler->Bind(label());
+    assembler->BindBlock(label());
   }
 
   // Throw away everything on the backtrack stack since the start
@@ -715,8 +709,8 @@ void EndNode::Emit(RegExpCompiler* compiler, Trace* trace) {
     return;
   }
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
-  if (!label()->is_bound()) {
-    assembler->Bind(label());
+  if (!label()->IsBound()) {
+    assembler->BindBlock(label());
   }
   switch (action_) {
     case ACCEPT:
@@ -733,37 +727,38 @@ void EndNode::Emit(RegExpCompiler* compiler, Trace* trace) {
 }
 
 
-void GuardedAlternative::AddGuard(Guard* guard, Zone* zone) {
+void GuardedAlternative::AddGuard(Guard* guard, Isolate* isolate) {
   if (guards_ == NULL)
-    guards_ = new(zone) ZoneList<Guard*>(1, zone);
-  guards_->Add(guard, zone);
+    guards_ = new(isolate) ZoneGrowableArray<Guard*>(1);
+  guards_->Add(guard);
 }
 
 
-ActionNode* ActionNode::SetRegister(int reg,
-                                    int val,
+ActionNode* ActionNode::SetRegister(intptr_t reg,
+                                    intptr_t val,
                                     RegExpNode* on_success) {
   ActionNode* result =
-      new(on_success->zone()) ActionNode(SET_REGISTER, on_success);
+      new(on_success->isolate()) ActionNode(SET_REGISTER, on_success);
   result->data_.u_store_register.reg = reg;
   result->data_.u_store_register.value = val;
   return result;
 }
 
 
-ActionNode* ActionNode::IncrementRegister(int reg, RegExpNode* on_success) {
+ActionNode* ActionNode::IncrementRegister(intptr_t reg,
+                                          RegExpNode* on_success) {
   ActionNode* result =
-      new(on_success->zone()) ActionNode(INCREMENT_REGISTER, on_success);
+      new(on_success->isolate()) ActionNode(INCREMENT_REGISTER, on_success);
   result->data_.u_increment_register.reg = reg;
   return result;
 }
 
 
-ActionNode* ActionNode::StorePosition(int reg,
+ActionNode* ActionNode::StorePosition(intptr_t reg,
                                       bool is_capture,
                                       RegExpNode* on_success) {
   ActionNode* result =
-      new(on_success->zone()) ActionNode(STORE_POSITION, on_success);
+      new(on_success->isolate()) ActionNode(STORE_POSITION, on_success);
   result->data_.u_position_register.reg = reg;
   result->data_.u_position_register.is_capture = is_capture;
   return result;
@@ -773,31 +768,32 @@ ActionNode* ActionNode::StorePosition(int reg,
 ActionNode* ActionNode::ClearCaptures(Interval range,
                                       RegExpNode* on_success) {
   ActionNode* result =
-      new(on_success->zone()) ActionNode(CLEAR_CAPTURES, on_success);
+      new(on_success->isolate()) 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(int stack_reg,
-                                      int position_reg,
+ActionNode* ActionNode::BeginSubmatch(intptr_t stack_reg,
+                                      intptr_t position_reg,
                                       RegExpNode* on_success) {
   ActionNode* result =
-      new(on_success->zone()) ActionNode(BEGIN_SUBMATCH, on_success);
+      new(on_success->isolate()) 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(int stack_reg,
-                                                int position_reg,
-                                                int clear_register_count,
-                                                int clear_register_from,
+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->zone()) ActionNode(POSITIVE_SUBMATCH_SUCCESS, on_success);
+      new(on_success->isolate()) 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;
@@ -806,12 +802,12 @@ ActionNode* ActionNode::PositiveSubmatchSuccess(int stack_reg,
 }
 
 
-ActionNode* ActionNode::EmptyMatchCheck(int start_register,
-                                        int repetition_register,
-                                        int repetition_limit,
+ActionNode* ActionNode::EmptyMatchCheck(intptr_t start_register,
+                                        intptr_t repetition_register,
+                                        intptr_t repetition_limit,
                                         RegExpNode* on_success) {
   ActionNode* result =
-      new(on_success->zone()) ActionNode(EMPTY_MATCH_CHECK, on_success);
+      new(on_success->isolate()) 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;
@@ -841,13 +837,13 @@ void ChoiceNode::GenerateGuard(RegExpMacroAssembler* macro_assembler,
                                Trace* trace) {
   switch (guard->op()) {
     case Guard::LT:
-      DCHECK(!trace->mentions_reg(guard->reg()));
+      ASSERT(!trace->mentions_reg(guard->reg()));
       macro_assembler->IfRegisterGE(guard->reg(),
                                     guard->value(),
                                     trace->backtrack());
       break;
     case Guard::GEQ:
-      DCHECK(!trace->mentions_reg(guard->reg()));
+      ASSERT(!trace->mentions_reg(guard->reg()));
       macro_assembler->IfRegisterLT(guard->reg(),
                                     guard->value(),
                                     trace->backtrack());
@@ -858,18 +854,18 @@ void ChoiceNode::GenerateGuard(RegExpMacroAssembler* macro_assembler,
 
 // Returns the number of characters in the equivalence class, omitting those
 // that cannot occur in the source string because it is ASCII.
-static int GetCaseIndependentLetters(Isolate* isolate, uc16 character,
-                                     bool one_byte_subject,
-                                     unibrow::uchar* letters) {
-  int length =
-      isolate->jsregexp_uncanonicalize()->get(character, '\0', letters);
+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 <= String::kMaxOneByteCharCode) {
+  if (!one_byte_subject || character <= Symbols::kMaxOneCharCodeSymbol) {
     return length;
   }
 
@@ -883,9 +879,9 @@ static int GetCaseIndependentLetters(Isolate* isolate, uc16 character,
 
 static inline bool EmitSimpleCharacter(Isolate* isolate,
                                        RegExpCompiler* compiler,
-                                       uc16 c,
-                                       Label* on_failure,
-                                       int cp_offset,
+                                       uint16_t c,
+                                       BlockLabel* on_failure,
+                                       intptr_t cp_offset,
                                        bool check,
                                        bool preloaded) {
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
@@ -906,15 +902,15 @@ static inline bool EmitSimpleCharacter(Isolate* isolate,
 // independent matches.
 static inline bool EmitAtomNonLetter(Isolate* isolate,
                                      RegExpCompiler* compiler,
-                                     uc16 c,
-                                     Label* on_failure,
-                                     int cp_offset,
+                                     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();
-  unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
-  int length = GetCaseIndependentLetters(isolate, c, one_byte, chars);
+  int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
+  intptr_t length = GetCaseIndependentLetters(c, one_byte, chars);
   if (length < 1) {
     // This can't match.  Must be an one-byte subject and a non-one-byte
     // character.  We do not need to do anything since the one-byte pass
@@ -924,7 +920,7 @@ static inline bool EmitAtomNonLetter(Isolate* isolate,
   bool checked = false;
   // We handle the length > 1 case in a later pass.
   if (length == 1) {
-    if (one_byte && c > String::kMaxOneByteCharCodeU) {
+    if (one_byte && c > Symbols::kMaxOneCharCodeSymbol) {
       // Can't match - see above.
       return false;  // Bounds not checked.
     }
@@ -939,32 +935,34 @@ static inline bool EmitAtomNonLetter(Isolate* isolate,
 
 
 static bool ShortCutEmitCharacterPair(RegExpMacroAssembler* macro_assembler,
-                                      bool one_byte, uc16 c1, uc16 c2,
-                                      Label* on_failure) {
-  uc16 char_mask;
+                                      bool one_byte,
+                                      uint16_t c1,
+                                      uint16_t c2,
+                                      BlockLabel* on_failure) {
+  uint16_t char_mask;
   if (one_byte) {
-    char_mask = String::kMaxOneByteCharCode;
+    char_mask = Symbols::kMaxOneCharCodeSymbol;
   } else {
-    char_mask = String::kMaxUtf16CodeUnit;
+    char_mask = Utf16::kMaxCodeUnit;
   }
-  uc16 exor = c1 ^ c2;
+  uint16_t exor = c1 ^ c2;
   // Check whether exor has only one bit set.
   if (((exor - 1) & exor) == 0) {
     // If c1 and c2 differ only by one bit.
     // Ecma262UnCanonicalize always gives the highest number last.
-    DCHECK(c2 > c1);
-    uc16 mask = char_mask ^ exor;
+    ASSERT(c2 > c1);
+    uint16_t mask = char_mask ^ exor;
     macro_assembler->CheckNotCharacterAfterAnd(c1, mask, on_failure);
     return true;
   }
-  DCHECK(c2 > c1);
-  uc16 diff = c2 - c1;
+  ASSERT(c2 > c1);
+  uint16_t diff = c2 - c1;
   if (((diff - 1) & diff) == 0 && c1 >= diff) {
     // If the characters differ by 2^n but don't differ by one bit then
     // subtract the difference from the found character, then do the or
     // trick.  We avoid the theoretical case where negative numbers are
     // involved in order to simplify code generation.
-    uc16 mask = char_mask ^ diff;
+    uint16_t mask = char_mask ^ diff;
     macro_assembler->CheckNotCharacterAfterMinusAnd(c1 - diff,
                                                     diff,
                                                     mask,
@@ -977,9 +975,9 @@ static bool ShortCutEmitCharacterPair(RegExpMacroAssembler* macro_assembler,
 
 typedef bool EmitCharacterFunction(Isolate* isolate,
                                    RegExpCompiler* compiler,
-                                   uc16 c,
-                                   Label* on_failure,
-                                   int cp_offset,
+                                   uint16_t c,
+                                   BlockLabel* on_failure,
+                                   intptr_t cp_offset,
                                    bool check,
                                    bool preloaded);
 
@@ -987,31 +985,34 @@ typedef bool EmitCharacterFunction(Isolate* isolate,
 // matches.
 static inline bool EmitAtomLetter(Isolate* isolate,
                                   RegExpCompiler* compiler,
-                                  uc16 c,
-                                  Label* on_failure,
-                                  int cp_offset,
+                                  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();
-  unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
-  int length = GetCaseIndependentLetters(isolate, c, one_byte, chars);
+  int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
+  intptr_t length = GetCaseIndependentLetters(c, one_byte, chars);
   if (length <= 1) return false;
   // We may not need to check against the end of the input string
   // if this character lies before a character that matched.
   if (!preloaded) {
     macro_assembler->LoadCurrentCharacter(cp_offset, on_failure, check);
   }
-  Label ok;
-  DCHECK(unibrow::Ecma262UnCanonicalize::kMaxWidth == 4);
+  BlockLabel ok;
+  ASSERT(unibrow::Ecma262UnCanonicalize::kMaxWidth == 4);
   switch (length) {
     case 2: {
-      if (ShortCutEmitCharacterPair(macro_assembler, one_byte, chars[0],
-                                    chars[1], on_failure)) {
+      if (ShortCutEmitCharacterPair(macro_assembler,
+                                    one_byte,
+                                    chars[0],
+                                    chars[1],
+                                    on_failure)) {
       } else {
         macro_assembler->CheckCharacter(chars[0], &ok);
         macro_assembler->CheckNotCharacter(chars[1], on_failure);
-        macro_assembler->Bind(&ok);
+        macro_assembler->BindBlock(&ok);
       }
       break;
     }
@@ -1022,7 +1023,7 @@ static inline bool EmitAtomLetter(Isolate* isolate,
       macro_assembler->CheckCharacter(chars[0], &ok);
       macro_assembler->CheckCharacter(chars[1], &ok);
       macro_assembler->CheckNotCharacter(chars[2], on_failure);
-      macro_assembler->Bind(&ok);
+      macro_assembler->BindBlock(&ok);
       break;
     default:
       UNREACHABLE();
@@ -1033,10 +1034,10 @@ static inline bool EmitAtomLetter(Isolate* isolate,
 
 
 static void EmitBoundaryTest(RegExpMacroAssembler* masm,
-                             int border,
-                             Label* fall_through,
-                             Label* above_or_equal,
-                             Label* below) {
+                             intptr_t border,
+                             BlockLabel* fall_through,
+                             BlockLabel* above_or_equal,
+                             BlockLabel* below) {
   if (below != fall_through) {
     masm->CheckCharacterLT(border, below);
     if (above_or_equal != fall_through) masm->GoTo(above_or_equal);
@@ -1047,11 +1048,11 @@ static void EmitBoundaryTest(RegExpMacroAssembler* masm,
 
 
 static void EmitDoubleBoundaryTest(RegExpMacroAssembler* masm,
-                                   int first,
-                                   int last,
-                                   Label* fall_through,
-                                   Label* in_range,
-                                   Label* out_of_range) {
+                                   intptr_t first,
+                                   intptr_t last,
+                                   BlockLabel* fall_through,
+                                   BlockLabel* in_range,
+                                   BlockLabel* out_of_range) {
   if (in_range == fall_through) {
     if (first == last) {
       masm->CheckNotCharacter(first, out_of_range);
@@ -1073,29 +1074,28 @@ static void EmitDoubleBoundaryTest(RegExpMacroAssembler* masm,
 // odd_label is for ranges[i] to ranges[i + 1] where i - start_index is odd.
 static void EmitUseLookupTable(
     RegExpMacroAssembler* masm,
-    ZoneList<int>* ranges,
-    int start_index,
-    int end_index,
-    int min_char,
-    Label* fall_through,
-    Label* even_label,
-    Label* odd_label) {
-  static const int kSize = RegExpMacroAssembler::kTableSize;
-  static const int kMask = RegExpMacroAssembler::kTableMask;
-
-  int base = (min_char & ~kMask);
-  USE(base);
+    ZoneGrowableArray<int>* ranges,
+    intptr_t start_index,
+    intptr_t end_index,
+    intptr_t min_char,
+    BlockLabel* fall_through,
+    BlockLabel* even_label,
+    BlockLabel* odd_label) {
+  static const intptr_t kSize = RegExpMacroAssembler::kTableSize;
+  static const intptr_t kMask = RegExpMacroAssembler::kTableMask;
+
+  intptr_t base = (min_char & ~kMask);
 
   // Assert that everything is on one kTableSize page.
-  for (int i = start_index; i <= end_index; i++) {
-    DCHECK_EQ(ranges->at(i) & ~kMask, base);
+  for (intptr_t i = start_index; i <= end_index; i++) {
+    ASSERT((ranges->At(i) & ~kMask) == base);
   }
-  DCHECK(start_index == 0 || (ranges->at(start_index - 1) & ~kMask) <= base);
+  ASSERT(start_index == 0 || (ranges->At(start_index - 1) & ~kMask) <= base);
 
   char templ[kSize];
-  Label* on_bit_set;
-  Label* on_bit_clear;
-  int bit;
+  BlockLabel* on_bit_set;
+  BlockLabel* on_bit_clear;
+  intptr_t bit;
   if (even_label == fall_through) {
     on_bit_set = odd_label;
     on_bit_clear = even_label;
@@ -1105,25 +1105,27 @@ static void EmitUseLookupTable(
     on_bit_clear = odd_label;
     bit = 0;
   }
-  for (int i = 0; i < (ranges->at(start_index) & kMask) && i < kSize; i++) {
+  for (intptr_t i = 0; i < (ranges->At(start_index) & kMask) && i < kSize;
+       i++) {
     templ[i] = bit;
   }
-  int j = 0;
+  intptr_t j = 0;
   bit ^= 1;
-  for (int i = start_index; i < end_index; i++) {
-    for (j = (ranges->at(i) & kMask); j < (ranges->at(i + 1) & kMask); j++) {
+  for (intptr_t i = start_index; i < end_index; i++) {
+    for (j = (ranges->At(i) & kMask); j < (ranges->At(i + 1) & kMask); j++) {
       templ[j] = bit;
     }
     bit ^= 1;
   }
-  for (int i = j; i < kSize; i++) {
+  for (intptr_t i = j; i < kSize; i++) {
     templ[i] = bit;
   }
-  Factory* factory = masm->zone()->isolate()->factory();
   // TODO(erikcorry): Cache these.
-  Handle<ByteArray> ba = factory->NewByteArray(kSize, TENURED);
-  for (int i = 0; i < kSize; i++) {
-    ba->set(i, templ[i]);
+  const TypedData& ba = TypedData::ZoneHandle(
+        masm->isolate(),
+        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);
@@ -1131,52 +1133,52 @@ static void EmitUseLookupTable(
 
 
 static void CutOutRange(RegExpMacroAssembler* masm,
-                        ZoneList<int>* ranges,
-                        int start_index,
-                        int end_index,
-                        int cut_index,
-                        Label* even_label,
-                        Label* odd_label) {
+                        ZoneGrowableArray<int>* ranges,
+                        intptr_t start_index,
+                        intptr_t end_index,
+                        intptr_t cut_index,
+                        BlockLabel* even_label,
+                        BlockLabel* odd_label) {
   bool odd = (((cut_index - start_index) & 1) == 1);
-  Label* in_range_label = odd ? odd_label : even_label;
-  Label dummy;
+  BlockLabel* in_range_label = odd ? odd_label : even_label;
+  BlockLabel dummy;
   EmitDoubleBoundaryTest(masm,
-                         ranges->at(cut_index),
-                         ranges->at(cut_index + 1) - 1,
+                         ranges->At(cut_index),
+                         ranges->At(cut_index + 1) - 1,
                          &dummy,
                          in_range_label,
                          &dummy);
-  DCHECK(!dummy.is_linked());
+  ASSERT(!dummy.IsLinked());
   // Cut out the single range by rewriting the array.  This creates a new
   // range that is a merger of the two ranges on either side of the one we
   // are cutting out.  The oddity of the labels is preserved.
-  for (int j = cut_index; j > start_index; j--) {
-    ranges->at(j) = ranges->at(j - 1);
+  for (intptr_t j = cut_index; j > start_index; j--) {
+    (*ranges)[j] = ranges->At(j - 1);
   }
-  for (int j = cut_index + 1; j < end_index; j++) {
-    ranges->at(j) = ranges->at(j + 1);
+  for (intptr_t j = cut_index + 1; j < end_index; j++) {
+    (*ranges)[j] = ranges->At(j + 1);
   }
 }
 
 
 // Unicode case.  Split the search space into kSize spaces that are handled
 // with recursion.
-static void SplitSearchSpace(ZoneList<int>* ranges,
-                             int start_index,
-                             int end_index,
-                             int* new_start_index,
-                             int* new_end_index,
-                             int* border) {
-  static const int kSize = RegExpMacroAssembler::kTableSize;
-  static const int kMask = RegExpMacroAssembler::kTableMask;
-
-  int first = ranges->at(start_index);
-  int last = ranges->at(end_index) - 1;
+static void SplitSearchSpace(ZoneGrowableArray<int>* ranges,
+                             intptr_t start_index,
+                             intptr_t end_index,
+                             intptr_t* new_start_index,
+                             intptr_t* new_end_index,
+                             intptr_t* border) {
+  static const intptr_t kSize = RegExpMacroAssembler::kTableSize;
+  static const intptr_t kMask = RegExpMacroAssembler::kTableMask;
+
+  intptr_t first = ranges->At(start_index);
+  intptr_t last = ranges->At(end_index) - 1;
 
   *new_start_index = start_index;
-  *border = (ranges->at(start_index) & ~kMask) + kSize;
+  *border = (ranges->At(start_index) & ~kMask) + kSize;
   while (*new_start_index < end_index) {
-    if (ranges->at(*new_start_index) > *border) break;
+    if (ranges->At(*new_start_index) > *border) break;
     (*new_start_index)++;
   }
   // new_start_index is the index of the first edge that is beyond the
@@ -1190,20 +1192,21 @@ static void SplitSearchSpace(ZoneList<int>* ranges,
   // 128-character space can take up a lot of space in the ranges array if,
   // for example, we only want to match every second character (eg. the lower
   // case characters on some Unicode pages).
-  int binary_chop_index = (end_index + start_index) / 2;
+  intptr_t binary_chop_index = (end_index + start_index) / 2;
   // The first test ensures that we get to the code that handles the Latin1
   // range with a single not-taken branch, speeding up this important
   // character range (even non-Latin1 charset-based text has spaces and
   // punctuation).
-  if (*border - 1 > String::kMaxOneByteCharCode &&  // Latin1 case.
+  if (*border - 1 > Symbols::kMaxOneCharCodeSymbol &&  // Latin1 case.
       end_index - start_index > (*new_start_index - start_index) * 2 &&
-      last - first > kSize * 2 && binary_chop_index > *new_start_index &&
-      ranges->at(binary_chop_index) >= first + 2 * kSize) {
-    int scan_forward_for_section_border = binary_chop_index;;
-    int new_border = (ranges->at(binary_chop_index) | kMask) + 1;
+      last - first > kSize * 2 &&
+      binary_chop_index > *new_start_index &&
+      ranges->At(binary_chop_index) >= first + 2 * kSize) {
+    intptr_t scan_forward_for_section_border = binary_chop_index;;
+    intptr_t new_border = (ranges->At(binary_chop_index) | kMask) + 1;
 
     while (scan_forward_for_section_border < end_index) {
-      if (ranges->at(scan_forward_for_section_border) > new_border) {
+      if (ranges->At(scan_forward_for_section_border) > new_border) {
         *new_start_index = scan_forward_for_section_border;
         *border = new_border;
         break;
@@ -1212,13 +1215,13 @@ static void SplitSearchSpace(ZoneList<int>* ranges,
     }
   }
 
-  DCHECK(*new_start_index > start_index);
+  ASSERT(*new_start_index > start_index);
   *new_end_index = *new_start_index - 1;
-  if (ranges->at(*new_end_index) == *border) {
+  if (ranges->At(*new_end_index) == *border) {
     (*new_end_index)--;
   }
-  if (*border >= ranges->at(end_index)) {
-    *border = ranges->at(end_index);
+  if (*border >= ranges->At(end_index)) {
+    *border = ranges->At(end_index);
     *new_start_index = end_index;  // Won't be used.
     *new_end_index = end_index - 1;
   }
@@ -1232,18 +1235,18 @@ static void SplitSearchSpace(ZoneList<int>* ranges,
 // Either label can be NULL indicating backtracking.  Either label can also be
 // equal to the fall_through label.
 static void GenerateBranches(RegExpMacroAssembler* masm,
-                             ZoneList<int>* ranges,
-                             int start_index,
-                             int end_index,
-                             uc16 min_char,
-                             uc16 max_char,
-                             Label* fall_through,
-                             Label* even_label,
-                             Label* odd_label) {
-  int first = ranges->at(start_index);
-  int last = ranges->at(end_index) - 1;
-
-  DCHECK_LT(min_char, first);
+                             ZoneGrowableArray<int>* ranges,
+                             intptr_t start_index,
+                             intptr_t end_index,
+                             uint16_t min_char,
+                             uint16_t max_char,
+                             BlockLabel* fall_through,
+                             BlockLabel* even_label,
+                             BlockLabel* odd_label) {
+  intptr_t first = ranges->At(start_index);
+  intptr_t last = ranges->At(end_index) - 1;
+
+  ASSERT(min_char < first);
 
   // Just need to test if the character is before or on-or-after
   // a particular character.
@@ -1265,10 +1268,10 @@ static void GenerateBranches(RegExpMacroAssembler* masm,
   if (end_index - start_index <= 6) {
     // It is faster to test for individual characters, so we look for those
     // first, then try arbitrary ranges in the second round.
-    static int kNoCutIndex = -1;
-    int cut = kNoCutIndex;
-    for (int i = start_index; i < end_index; i++) {
-      if (ranges->at(i) == ranges->at(i + 1) - 1) {
+    static intptr_t kNoCutIndex = -1;
+    intptr_t cut = kNoCutIndex;
+    for (intptr_t i = start_index; i < end_index; i++) {
+      if (ranges->At(i) == ranges->At(i + 1) - 1) {
         cut = i;
         break;
       }
@@ -1276,7 +1279,7 @@ static void GenerateBranches(RegExpMacroAssembler* masm,
     if (cut == kNoCutIndex) cut = start_index;
     CutOutRange(
         masm, ranges, start_index, end_index, cut, even_label, odd_label);
-    DCHECK_GE(end_index - start_index, 2);
+    ASSERT(end_index - start_index >= 2);
     GenerateBranches(masm,
                      ranges,
                      start_index + 1,
@@ -1291,7 +1294,7 @@ static void GenerateBranches(RegExpMacroAssembler* masm,
 
   // If there are a lot of intervals in the regexp, then we will use tables to
   // determine whether the character is inside or outside the character class.
-  static const int kBits = RegExpMacroAssembler::kTableSizeBits;
+  static const intptr_t kBits = RegExpMacroAssembler::kTableSizeBits;
 
   if ((max_char >> kBits) == (min_char >> kBits)) {
     EmitUseLookupTable(masm,
@@ -1319,9 +1322,9 @@ static void GenerateBranches(RegExpMacroAssembler* masm,
     return;
   }
 
-  int new_start_index = 0;
-  int new_end_index = 0;
-  int border = 0;
+  intptr_t new_start_index = 0;
+  intptr_t new_end_index = 0;
+  intptr_t border = 0;
 
   SplitSearchSpace(ranges,
                    start_index,
@@ -1330,34 +1333,34 @@ static void GenerateBranches(RegExpMacroAssembler* masm,
                    &new_end_index,
                    &border);
 
-  Label handle_rest;
-  Label* above = &handle_rest;
+  BlockLabel handle_rest;
+  BlockLabel* above = &handle_rest;
   if (border == last + 1) {
     // We didn't find any section that started after the limit, so everything
     // above the border is one of the terminal labels.
     above = (end_index & 1) != (start_index & 1) ? odd_label : even_label;
-    DCHECK(new_end_index == end_index - 1);
+    ASSERT(new_end_index == end_index - 1);
   }
 
-  DCHECK_LE(start_index, new_end_index);
-  DCHECK_LE(new_start_index, end_index);
-  DCHECK_LT(start_index, new_start_index);
-  DCHECK_LT(new_end_index, end_index);
-  DCHECK(new_end_index + 1 == new_start_index ||
+  ASSERT(start_index <= new_end_index);
+  ASSERT(new_start_index <= end_index);
+  ASSERT(start_index < new_start_index);
+  ASSERT(new_end_index < end_index);
+  ASSERT(new_end_index + 1 == new_start_index ||
          (new_end_index + 2 == new_start_index &&
-          border == ranges->at(new_end_index + 1)));
-  DCHECK_LT(min_char, border - 1);
-  DCHECK_LT(border, max_char);
-  DCHECK_LT(ranges->at(new_end_index), border);
-  DCHECK(border < ranges->at(new_start_index) ||
-         (border == ranges->at(new_start_index) &&
+          border == ranges->At(new_end_index + 1)));
+  ASSERT(min_char < border - 1);
+  ASSERT(border < max_char);
+  ASSERT(ranges->At(new_end_index) < border);
+  ASSERT(border < ranges->At(new_start_index) ||
+         (border == ranges->At(new_start_index) &&
           new_start_index == end_index &&
           new_end_index == end_index - 1 &&
           border == last + 1));
-  DCHECK(new_start_index == 0 || border >= ranges->at(new_start_index - 1));
+  ASSERT(new_start_index == 0 || border >= ranges->At(new_start_index - 1));
 
   masm->CheckCharacterGT(border - 1, above);
-  Label dummy;
+  BlockLabel dummy;
   GenerateBranches(masm,
                    ranges,
                    start_index,
@@ -1367,8 +1370,9 @@ static void GenerateBranches(RegExpMacroAssembler* masm,
                    &dummy,
                    even_label,
                    odd_label);
-  if (handle_rest.is_linked()) {
-    masm->Bind(&handle_rest);
+
+  if (handle_rest.IsLinked()) {
+    masm->BindBlock(&handle_rest);
     bool flip = (new_start_index & 1) != (start_index & 1);
     GenerateBranches(masm,
                      ranges,
@@ -1384,26 +1388,30 @@ static void GenerateBranches(RegExpMacroAssembler* masm,
 
 
 static void EmitCharClass(RegExpMacroAssembler* macro_assembler,
-                          RegExpCharacterClass* cc, bool one_byte,
-                          Label* on_failure, int cp_offset, bool check_offset,
-                          bool preloaded, Zone* zone) {
-  ZoneList<CharacterRange>* ranges = cc->ranges(zone);
+                          RegExpCharacterClass* cc,
+                          bool one_byte,
+                          BlockLabel* on_failure,
+                          intptr_t cp_offset,
+                          bool check_offset,
+                          bool preloaded,
+                          Isolate* isolate) {
+  ZoneGrowableArray<CharacterRange>* ranges = cc->ranges();
   if (!CharacterRange::IsCanonical(ranges)) {
     CharacterRange::Canonicalize(ranges);
   }
 
-  int max_char;
+  intptr_t max_char;
   if (one_byte) {
-    max_char = String::kMaxOneByteCharCode;
+    max_char = Symbols::kMaxOneCharCodeSymbol;
   } else {
-    max_char = String::kMaxUtf16CodeUnit;
+    max_char = Utf16::kMaxCodeUnit;
   }
 
-  int range_count = ranges->length();
+  intptr_t range_count = ranges->length();
 
-  int last_valid_range = range_count - 1;
+  intptr_t last_valid_range = range_count - 1;
   while (last_valid_range >= 0) {
-    CharacterRange& range = ranges->at(last_valid_range);
+    CharacterRange& range = (*ranges)[last_valid_range];
     if (range.from() <= max_char) {
       break;
     }
@@ -1421,7 +1429,7 @@ static void EmitCharClass(RegExpMacroAssembler* macro_assembler,
   }
 
   if (last_valid_range == 0 &&
-      ranges->at(0).IsEverything(max_char)) {
+      ranges->At(0).IsEverything(max_char)) {
     if (cc->is_negated()) {
       macro_assembler->GoTo(on_failure);
     } else {
@@ -1434,7 +1442,7 @@ static void EmitCharClass(RegExpMacroAssembler* macro_assembler,
   }
   if (last_valid_range == 0 &&
       !cc->is_negated() &&
-      ranges->at(0).IsEverything(max_char)) {
+      ranges->At(0).IsEverything(max_char)) {
     // This is a common case hit by non-anchored expressions.
     if (check_offset) {
       macro_assembler->CheckPosition(cp_offset, on_failure);
@@ -1446,7 +1454,7 @@ static void EmitCharClass(RegExpMacroAssembler* macro_assembler,
     macro_assembler->LoadCurrentCharacter(cp_offset, on_failure, check_offset);
   }
 
-  if (cc->is_standard(zone) &&
+  if (cc->is_standard() &&
         macro_assembler->CheckSpecialCharacterClass(cc->standard_type(),
                                                     on_failure)) {
       return;
@@ -1459,27 +1467,27 @@ static void EmitCharClass(RegExpMacroAssembler* macro_assembler,
   // 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).
-  ZoneList<int>* range_boundaries =
-      new(zone) ZoneList<int>(last_valid_range, zone);
+  ZoneGrowableArray<int>* range_boundaries =
+      new(isolate) ZoneGrowableArray<int>(last_valid_range);
 
   bool zeroth_entry_is_failure = !cc->is_negated();
 
-  for (int i = 0; i <= last_valid_range; i++) {
-    CharacterRange& range = ranges->at(i);
+  for (intptr_t i = 0; i <= last_valid_range; i++) {
+    CharacterRange& range = (*ranges)[i];
     if (range.from() == 0) {
-      DCHECK_EQ(i, 0);
+      ASSERT(i == 0);
       zeroth_entry_is_failure = !zeroth_entry_is_failure;
     } else {
-      range_boundaries->Add(range.from(), zone);
+      range_boundaries->Add(range.from());
     }
-    range_boundaries->Add(range.to() + 1, zone);
+    range_boundaries->Add(range.to() + 1);
   }
-  int end_index = range_boundaries->length() - 1;
-  if (range_boundaries->at(end_index) > max_char) {
+  intptr_t end_index = range_boundaries->length() - 1;
+  if (range_boundaries->At(end_index) > max_char) {
     end_index--;
   }
 
-  Label fall_through;
+  BlockLabel fall_through;
   GenerateBranches(macro_assembler,
                    range_boundaries,
                    0,  // start_index.
@@ -1489,7 +1497,7 @@ static void EmitCharClass(RegExpMacroAssembler* macro_assembler,
                    &fall_through,
                    zeroth_entry_is_failure ? &fall_through : on_failure,
                    zeroth_entry_is_failure ? on_failure : &fall_through);
-  macro_assembler->Bind(&fall_through);
+  macro_assembler->BindBlock(&fall_through);
 }
 
 
@@ -1506,7 +1514,7 @@ RegExpNode::LimitResult RegExpNode::LimitVersions(RegExpCompiler* compiler,
 
   RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
   if (trace->is_trivial()) {
-    if (label_.is_bound()) {
+    if (label_.IsBound()) {
       // We are being asked to generate a generic version, but that's already
       // been done so just go to it.
       macro_assembler->GoTo(&label_);
@@ -1520,14 +1528,14 @@ RegExpNode::LimitResult RegExpNode::LimitVersions(RegExpCompiler* compiler,
       return DONE;
     }
     // Generate generic version of the node and bind the label for later use.
-    macro_assembler->Bind(&label_);
+    macro_assembler->BindBlock(&label_);
     return CONTINUE;
   }
 
   // We are being asked to make a non-generic version.  Keep track of how many
   // non-generic versions we generate so as not to overdo it.
   trace_count_++;
-  if (FLAG_regexp_optimization &&
+  if (kRegexpOptimization &&
       trace_count_ < kMaxCopiesCodeGenerated &&
       compiler->recursion_depth() <= RegExpCompiler::kMaxRecursion) {
     return CONTINUE;
@@ -1541,9 +1549,9 @@ RegExpNode::LimitResult RegExpNode::LimitVersions(RegExpCompiler* compiler,
 }
 
 
-int ActionNode::EatsAtLeast(int still_to_find,
-                            int budget,
-                            bool not_at_start) {
+intptr_t ActionNode::EatsAtLeast(intptr_t still_to_find,
+                                 intptr_t budget,
+                                 bool not_at_start) {
   if (budget <= 0) return 0;
   if (action_type_ == POSITIVE_SUBMATCH_SUCCESS) return 0;  // Rewinds input!
   return on_success()->EatsAtLeast(still_to_find,
@@ -1552,8 +1560,8 @@ int ActionNode::EatsAtLeast(int still_to_find,
 }
 
 
-void ActionNode::FillInBMInfo(int offset,
-                              int budget,
+void ActionNode::FillInBMInfo(intptr_t offset,
+                              intptr_t budget,
                               BoyerMooreLookahead* bm,
                               bool not_at_start) {
   if (action_type_ == BEGIN_SUBMATCH) {
@@ -1565,9 +1573,9 @@ void ActionNode::FillInBMInfo(int offset,
 }
 
 
-int AssertionNode::EatsAtLeast(int still_to_find,
-                               int budget,
-                               bool not_at_start) {
+intptr_t AssertionNode::EatsAtLeast(intptr_t still_to_find,
+                                    intptr_t budget,
+                                    bool not_at_start) {
   if (budget <= 0) return 0;
   // If we know we are not at the start and we are asked "how many characters
   // will you match if you succeed?" then we can answer anything since false
@@ -1581,8 +1589,8 @@ int AssertionNode::EatsAtLeast(int still_to_find,
 }
 
 
-void AssertionNode::FillInBMInfo(int offset,
-                                 int budget,
+void AssertionNode::FillInBMInfo(intptr_t offset,
+                                 intptr_t budget,
                                  BoyerMooreLookahead* bm,
                                  bool not_at_start) {
   // Match the behaviour of EatsAtLeast on this node.
@@ -1592,9 +1600,9 @@ void AssertionNode::FillInBMInfo(int offset,
 }
 
 
-int BackReferenceNode::EatsAtLeast(int still_to_find,
-                                   int budget,
-                                   bool not_at_start) {
+intptr_t BackReferenceNode::EatsAtLeast(intptr_t still_to_find,
+                                        intptr_t budget,
+                                        bool not_at_start) {
   if (budget <= 0) return 0;
   return on_success()->EatsAtLeast(still_to_find,
                                    budget - 1,
@@ -1602,10 +1610,10 @@ int BackReferenceNode::EatsAtLeast(int still_to_find,
 }
 
 
-int TextNode::EatsAtLeast(int still_to_find,
-                          int budget,
-                          bool not_at_start) {
-  int answer = Length();
+intptr_t TextNode::EatsAtLeast(intptr_t still_to_find,
+                               intptr_t budget,
+                               bool not_at_start) {
+  intptr_t answer = Length();
   if (answer >= still_to_find) return answer;
   if (budget <= 0) return answer;
   // We are not at start after this node so we set the last argument to 'true'.
@@ -1615,13 +1623,13 @@ int TextNode::EatsAtLeast(int still_to_find,
 }
 
 
-int NegativeLookaheadChoiceNode::EatsAtLeast(int still_to_find,
-                                             int budget,
-                                             bool not_at_start) {
+intptr_t NegativeLookaheadChoiceNode::EatsAtLeast(intptr_t still_to_find,
+                                                  intptr_t budget,
+                                                  bool not_at_start) {
   if (budget <= 0) return 0;
   // Alternative 0 is the negative lookahead, alternative 1 is what comes
   // afterwards.
-  RegExpNode* node = alternatives_->at(1).node();
+  RegExpNode* node = (*alternatives_)[1].node();
   return node->EatsAtLeast(still_to_find, budget - 1, not_at_start);
 }
 
@@ -1629,27 +1637,27 @@ int NegativeLookaheadChoiceNode::EatsAtLeast(int still_to_find,
 void NegativeLookaheadChoiceNode::GetQuickCheckDetails(
     QuickCheckDetails* details,
     RegExpCompiler* compiler,
-    int filled_in,
+    intptr_t filled_in,
     bool not_at_start) {
   // Alternative 0 is the negative lookahead, alternative 1 is what comes
   // afterwards.
-  RegExpNode* node = alternatives_->at(1).node();
+  RegExpNode* node = (*alternatives_)[1].node();
   return node->GetQuickCheckDetails(details, compiler, filled_in, not_at_start);
 }
 
 
-int ChoiceNode::EatsAtLeastHelper(int still_to_find,
-                                  int budget,
-                                  RegExpNode* ignore_this_node,
-                                  bool not_at_start) {
+intptr_t ChoiceNode::EatsAtLeastHelper(intptr_t still_to_find,
+                                       intptr_t budget,
+                                       RegExpNode* ignore_this_node,
+                                       bool not_at_start) {
   if (budget <= 0) return 0;
-  int min = 100;
-  int choice_count = alternatives_->length();
+  intptr_t min = 100;
+  intptr_t choice_count = alternatives_->length();
   budget = (budget - 1) / choice_count;
-  for (int i = 0; i < choice_count; i++) {
-    RegExpNode* node = alternatives_->at(i).node();
+  for (intptr_t i = 0; i < choice_count; i++) {
+    RegExpNode* node = (*alternatives_)[i].node();
     if (node == ignore_this_node) continue;
-    int node_eats_at_least =
+    intptr_t node_eats_at_least =
         node->EatsAtLeast(still_to_find, budget, not_at_start);
     if (node_eats_at_least < min) min = node_eats_at_least;
     if (min == 0) return 0;
@@ -1658,9 +1666,9 @@ int ChoiceNode::EatsAtLeastHelper(int still_to_find,
 }
 
 
-int LoopChoiceNode::EatsAtLeast(int still_to_find,
-                                int budget,
-                                bool not_at_start) {
+intptr_t LoopChoiceNode::EatsAtLeast(intptr_t still_to_find,
+                                     intptr_t budget,
+                                     bool not_at_start) {
   return EatsAtLeastHelper(still_to_find,
                            budget - 1,
                            loop_node_,
@@ -1668,9 +1676,9 @@ int LoopChoiceNode::EatsAtLeast(int still_to_find,
 }
 
 
-int ChoiceNode::EatsAtLeast(int still_to_find,
-                            int budget,
-                            bool not_at_start) {
+intptr_t ChoiceNode::EatsAtLeast(intptr_t still_to_find,
+                                 intptr_t budget,
+                                 bool not_at_start) {
   return EatsAtLeastHelper(still_to_find,
                            budget,
                            NULL,
@@ -1693,16 +1701,16 @@ bool QuickCheckDetails::Rationalize(bool asc) {
   bool found_useful_op = false;
   uint32_t char_mask;
   if (asc) {
-    char_mask = String::kMaxOneByteCharCode;
+    char_mask = Symbols::kMaxOneCharCodeSymbol;
   } else {
-    char_mask = String::kMaxUtf16CodeUnit;
+    char_mask = Utf16::kMaxCodeUnit;
   }
   mask_ = 0;
   value_ = 0;
-  int char_shift = 0;
-  for (int i = 0; i < characters_; i++) {
+  intptr_t char_shift = 0;
+  for (intptr_t i = 0; i < characters_; i++) {
     Position* pos = &positions_[i];
-    if ((pos->mask & String::kMaxOneByteCharCode) != 0) {
+    if ((pos->mask & Symbols::kMaxOneCharCodeSymbol) != 0) {
       found_useful_op = true;
     }
     mask_ |= (pos->mask & char_mask) << char_shift;
@@ -1717,7 +1725,7 @@ bool RegExpNode::EmitQuickCheck(RegExpCompiler* compiler,
                                 Trace* bounds_check_trace,
                                 Trace* trace,
                                 bool preload_has_checked_bounds,
-                                Label* on_possible_success,
+                                BlockLabel* on_possible_success,
                                 QuickCheckDetails* details,
                                 bool fall_through_on_failure) {
   if (details->characters() == 0) return false;
@@ -1725,7 +1733,7 @@ bool RegExpNode::EmitQuickCheck(RegExpCompiler* compiler,
       details, compiler, 0, trace->at_start() == Trace::FALSE_VALUE);
   if (details->cannot_match()) return false;
   if (!details->Rationalize(compiler->one_byte())) return false;
-  DCHECK(details->characters() == 1 ||
+  ASSERT(details->characters() == 1 ||
          compiler->macro_assembler()->CanReadUnaligned());
   uint32_t mask = details->mask();
   uint32_t value = details->value();
@@ -1733,7 +1741,7 @@ bool RegExpNode::EmitQuickCheck(RegExpCompiler* compiler,
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
 
   if (trace->characters_preloaded() != details->characters()) {
-    DCHECK(trace->cp_offset() == bounds_check_trace->cp_offset());
+    ASSERT(trace->cp_offset() == bounds_check_trace->cp_offset());
     // We are attempting to preload the minimum number of characters
     // any choice would eat, so if the bounds check fails, then none of the
     // choices can succeed, so we can just immediately backtrack, rather
@@ -1752,9 +1760,9 @@ bool RegExpNode::EmitQuickCheck(RegExpCompiler* compiler,
     // load so the value is already masked down.
     uint32_t char_mask;
     if (compiler->one_byte()) {
-      char_mask = String::kMaxOneByteCharCode;
+      char_mask = Symbols::kMaxOneCharCodeSymbol;
     } else {
-      char_mask = String::kMaxUtf16CodeUnit;
+      char_mask = Utf16::kMaxCodeUnit;
     }
     if ((mask & char_mask) == char_mask) need_mask = false;
     mask &= char_mask;
@@ -1797,28 +1805,32 @@ bool RegExpNode::EmitQuickCheck(RegExpCompiler* compiler,
 // generating a quick check.
 void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
-                                    int characters_filled_in,
+                                    intptr_t characters_filled_in,
                                     bool not_at_start) {
-  Isolate* isolate = compiler->macro_assembler()->zone()->isolate();
-  DCHECK(characters_filled_in < details->characters());
-  int characters = details->characters();
-  int char_mask;
+#if defined(__GNUC__)
+  // TODO(zerny): Make the combination code byte-order independent.
+  ASSERT(details->characters() == 1 ||
+         (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__));
+#endif
+  ASSERT(characters_filled_in < details->characters());
+  intptr_t characters = details->characters();
+  intptr_t char_mask;
   if (compiler->one_byte()) {
-    char_mask = String::kMaxOneByteCharCode;
+    char_mask = Symbols::kMaxOneCharCodeSymbol;
   } else {
-    char_mask = String::kMaxUtf16CodeUnit;
+    char_mask = Utf16::kMaxCodeUnit;
   }
-  for (int k = 0; k < elms_->length(); k++) {
-    TextElement elm = elms_->at(k);
+  for (intptr_t k = 0; k < elms_->length(); k++) {
+    TextElement elm = elms_->At(k);
     if (elm.text_type() == TextElement::ATOM) {
-      Vector<const uc16> quarks = elm.atom()->data();
-      for (int i = 0; i < characters && i < quarks.length(); i++) {
+      ZoneGrowableArray<uint16_t>* quarks = elm.atom()->data();
+      for (intptr_t i = 0; i < characters && i < quarks->length(); i++) {
         QuickCheckDetails::Position* pos =
             details->positions(characters_filled_in);
-        uc16 c = quarks[i];
+        uint16_t c = quarks->At(i);
         if (c > char_mask) {
           // If we expect a non-Latin1 character from an one-byte string,
-          // there is no way we can match. Not even case-independent
+          // there is no way we can match. Not even case independent
           // matching can turn an Latin1 character into non-Latin1 or
           // vice versa.
           // TODO(dcarney): issue 3550.  Verify that this works as expected.
@@ -1828,10 +1840,10 @@ void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
           return;
         }
         if (compiler->ignore_case()) {
-          unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
-          int length = GetCaseIndependentLetters(isolate, c,
-                                                 compiler->one_byte(), chars);
-          DCHECK(length != 0);  // Can only happen if c > char_mask (see above).
+          int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
+          intptr_t length =
+              GetCaseIndependentLetters(c, compiler->one_byte(), chars);
+          ASSERT(length != 0);  // Can only happen if c > char_mask (see above).
           if (length == 1) {
             // This letter has no case equivalents, so it's nice and simple
             // and the mask-compare will determine definitely whether we have
@@ -1842,7 +1854,7 @@ void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
           } else {
             uint32_t common_bits = char_mask;
             uint32_t bits = chars[0];
-            for (int j = 1; j < length; j++) {
+            for (intptr_t j = 1; j < length; j++) {
               uint32_t differing_bits = ((chars[j] & common_bits) ^ bits);
               common_bits ^= differing_bits;
               bits &= common_bits;
@@ -1867,7 +1879,7 @@ void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
           pos->determines_perfectly = true;
         }
         characters_filled_in++;
-        DCHECK(characters_filled_in <= details->characters());
+        ASSERT(characters_filled_in <= details->characters());
         if (characters_filled_in == details->characters()) {
           return;
         }
@@ -1876,7 +1888,7 @@ void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
       QuickCheckDetails::Position* pos =
           details->positions(characters_filled_in);
       RegExpCharacterClass* tree = elm.char_class();
-      ZoneList<CharacterRange>* ranges = tree->ranges(zone());
+      ZoneGrowableArray<CharacterRange>* ranges = tree->ranges();
       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
@@ -1885,8 +1897,8 @@ void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
         pos->mask = 0;
         pos->value = 0;
       } else {
-        int first_range = 0;
-        while (ranges->at(first_range).from() > char_mask) {
+        intptr_t first_range = 0;
+        while (ranges->At(first_range).from() > char_mask) {
           first_range++;
           if (first_range == ranges->length()) {
             details->set_cannot_match();
@@ -1894,9 +1906,9 @@ void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
             return;
           }
         }
-        CharacterRange range = ranges->at(first_range);
-        uc16 from = range.from();
-        uc16 to = range.to();
+        CharacterRange range = ranges->At(first_range);
+        uint16_t from = range.from();
+        uint16_t to = range.to();
         if (to > char_mask) {
           to = char_mask;
         }
@@ -1909,10 +1921,10 @@ void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
         }
         uint32_t common_bits = ~SmearBitsRight(differing_bits);
         uint32_t bits = (from & common_bits);
-        for (int i = first_range + 1; i < ranges->length(); i++) {
-          CharacterRange range = ranges->at(i);
-          uc16 from = range.from();
-          uc16 to = range.to();
+        for (intptr_t i = first_range + 1; i < ranges->length(); i++) {
+          CharacterRange range = ranges->At(i);
+          uint16_t from = range.from();
+          uint16_t to = range.to();
           if (from > char_mask) continue;
           if (to > char_mask) to = char_mask;
           // Here we are combining more ranges into the mask and compare
@@ -1933,13 +1945,13 @@ void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
         pos->value = bits;
       }
       characters_filled_in++;
-      DCHECK(characters_filled_in <= details->characters());
+      ASSERT(characters_filled_in <= details->characters());
       if (characters_filled_in == details->characters()) {
         return;
       }
     }
   }
-  DCHECK(characters_filled_in != details->characters());
+  ASSERT(characters_filled_in != details->characters());
   if (!details->cannot_match()) {
     on_success()-> GetQuickCheckDetails(details,
                                         compiler,
@@ -1959,16 +1971,16 @@ void QuickCheckDetails::Clear() {
 }
 
 
-void QuickCheckDetails::Advance(int by, bool one_byte) {
-  DCHECK(by >= 0);
+void QuickCheckDetails::Advance(intptr_t by, bool one_byte) {
+  ASSERT(by >= 0);
   if (by >= characters_) {
     Clear();
     return;
   }
-  for (int i = 0; i < characters_ - by; i++) {
+  for (intptr_t i = 0; i < characters_ - by; i++) {
     positions_[i] = positions_[by + i];
   }
-  for (int i = characters_ - by; i < characters_; i++) {
+  for (intptr_t i = characters_ - by; i < characters_; i++) {
     positions_[i].mask = 0;
     positions_[i].value = 0;
     positions_[i].determines_perfectly = false;
@@ -1980,8 +1992,8 @@ void QuickCheckDetails::Advance(int by, bool one_byte) {
 }
 
 
-void QuickCheckDetails::Merge(QuickCheckDetails* other, int from_index) {
-  DCHECK(characters_ == other->characters_);
+void QuickCheckDetails::Merge(QuickCheckDetails* other, intptr_t from_index) {
+  ASSERT(characters_ == other->characters_);
   if (other->cannot_match_) {
     return;
   }
@@ -1989,7 +2001,7 @@ void QuickCheckDetails::Merge(QuickCheckDetails* other, int from_index) {
     *this = *other;
     return;
   }
-  for (int i = from_index; i < characters_; i++) {
+  for (intptr_t i = from_index; i < characters_; i++) {
     QuickCheckDetails::Position* pos = positions(i);
     QuickCheckDetails::Position* other_pos = other->positions(i);
     if (pos->mask != other_pos->mask ||
@@ -2002,17 +2014,17 @@ void QuickCheckDetails::Merge(QuickCheckDetails* other, int from_index) {
     pos->mask &= other_pos->mask;
     pos->value &= pos->mask;
     other_pos->value &= pos->mask;
-    uc16 differing_bits = (pos->value ^ other_pos->value);
+    uint16_t differing_bits = (pos->value ^ other_pos->value);
     pos->mask &= ~differing_bits;
     pos->value &= pos->mask;
   }
 }
 
 
-class VisitMarker {
+class VisitMarker : public ValueObject {
  public:
   explicit VisitMarker(NodeInfo* info) : info_(info) {
-    DCHECK(!info->visited);
+    ASSERT(!info->visited);
     info->visited = true;
   }
   ~VisitMarker() {
@@ -2023,16 +2035,16 @@ class VisitMarker {
 };
 
 
-RegExpNode* SeqRegExpNode::FilterOneByte(int depth, bool ignore_case) {
+RegExpNode* SeqRegExpNode::FilterOneByte(intptr_t depth, bool ignore_case) {
   if (info()->replacement_calculated) return replacement();
   if (depth < 0) return this;
-  DCHECK(!info()->visited);
+  ASSERT(!info()->visited);
   VisitMarker marker(info());
   return FilterSuccessor(depth - 1, ignore_case);
 }
 
 
-RegExpNode* SeqRegExpNode::FilterSuccessor(int depth, bool ignore_case) {
+RegExpNode* SeqRegExpNode::FilterSuccessor(intptr_t depth, bool ignore_case) {
   RegExpNode* next = on_success_->FilterOneByte(depth - 1, ignore_case);
   if (next == NULL) return set_replacement(NULL);
   on_success_ = next;
@@ -2048,58 +2060,74 @@ static inline bool RangeContainsLatin1Equivalents(CharacterRange range) {
 }
 
 
-static bool RangesContainLatin1Equivalents(ZoneList<CharacterRange>* ranges) {
-  for (int i = 0; i < ranges->length(); i++) {
+static bool RangesContainLatin1Equivalents(
+    ZoneGrowableArray<CharacterRange>* ranges) {
+  for (intptr_t i = 0; i < ranges->length(); i++) {
     // TODO(dcarney): this could be a lot more efficient.
-    if (RangeContainsLatin1Equivalents(ranges->at(i))) return true;
+    if (RangeContainsLatin1Equivalents(ranges->At(i))) return true;
   }
   return false;
 }
 
 
-RegExpNode* TextNode::FilterOneByte(int depth, bool ignore_case) {
+static uint16_t ConvertNonLatin1ToLatin1(uint16_t c) {
+  ASSERT(c > Symbols::kMaxOneCharCodeSymbol);
+  switch (c) {
+    // This are equivalent characters in unicode.
+    case 0x39c:
+    case 0x3bc:
+      return 0xb5;
+    // This is an uppercase of a Latin-1 character
+    // outside of Latin-1.
+    case 0x178:
+      return 0xff;
+  }
+  return 0;
+}
+
+
+RegExpNode* TextNode::FilterOneByte(intptr_t depth, bool ignore_case) {
   if (info()->replacement_calculated) return replacement();
   if (depth < 0) return this;
-  DCHECK(!info()->visited);
+  ASSERT(!info()->visited);
   VisitMarker marker(info());
-  int element_count = elms_->length();
-  for (int i = 0; i < element_count; i++) {
-    TextElement elm = elms_->at(i);
+  intptr_t element_count = elms_->length();
+  for (intptr_t i = 0; i < element_count; i++) {
+    TextElement elm = elms_->At(i);
     if (elm.text_type() == TextElement::ATOM) {
-      Vector<const uc16> quarks = elm.atom()->data();
-      for (int j = 0; j < quarks.length(); j++) {
-        uint16_t c = quarks[j];
-        if (c <= String::kMaxOneByteCharCode) continue;
+      ZoneGrowableArray<uint16_t>* quarks = elm.atom()->data();
+      for (intptr_t j = 0; j < quarks->length(); j++) {
+        uint16_t c = quarks->At(j);
+        if (c <= Symbols::kMaxOneCharCodeSymbol) continue;
         if (!ignore_case) return set_replacement(NULL);
         // Here, we need to check for characters whose upper and lower cases
         // are outside the Latin-1 range.
-        uint16_t converted = unibrow::Latin1::ConvertNonLatin1ToLatin1(c);
+        uint16_t converted = ConvertNonLatin1ToLatin1(c);
         // Character is outside Latin-1 completely
         if (converted == 0) return set_replacement(NULL);
         // Convert quark to Latin-1 in place.
-        uint16_t* copy = const_cast<uint16_t*>(quarks.start());
-        copy[j] = converted;
+        (*quarks)[0] = converted;
       }
     } else {
-      DCHECK(elm.text_type() == TextElement::CHAR_CLASS);
+      ASSERT(elm.text_type() == TextElement::CHAR_CLASS);
       RegExpCharacterClass* cc = elm.char_class();
-      ZoneList<CharacterRange>* ranges = cc->ranges(zone());
+      ZoneGrowableArray<CharacterRange>* ranges = cc->ranges();
       if (!CharacterRange::IsCanonical(ranges)) {
         CharacterRange::Canonicalize(ranges);
       }
       // Now they are in order so we only need to look at the first.
-      int range_count = ranges->length();
+      intptr_t range_count = ranges->length();
       if (cc->is_negated()) {
         if (range_count != 0 &&
-            ranges->at(0).from() == 0 &&
-            ranges->at(0).to() >= String::kMaxOneByteCharCode) {
+            ranges->At(0).from() == 0 &&
+            ranges->At(0).to() >= Symbols::kMaxOneCharCodeSymbol) {
           // This will be handled in a later filter.
           if (ignore_case && RangesContainLatin1Equivalents(ranges)) continue;
           return set_replacement(NULL);
         }
       } else {
         if (range_count == 0 ||
-            ranges->at(0).from() > String::kMaxOneByteCharCode) {
+            ranges->At(0).from() > Symbols::kMaxOneCharCodeSymbol) {
           // This will be handled in a later filter.
           if (ignore_case && RangesContainLatin1Equivalents(ranges)) continue;
           return set_replacement(NULL);
@@ -2111,7 +2139,7 @@ RegExpNode* TextNode::FilterOneByte(int depth, bool ignore_case) {
 }
 
 
-RegExpNode* LoopChoiceNode::FilterOneByte(int depth, bool ignore_case) {
+RegExpNode* LoopChoiceNode::FilterOneByte(intptr_t depth, bool ignore_case) {
   if (info()->replacement_calculated) return replacement();
   if (depth < 0) return this;
   if (info()->visited) return this;
@@ -2129,30 +2157,30 @@ RegExpNode* LoopChoiceNode::FilterOneByte(int depth, bool ignore_case) {
 }
 
 
-RegExpNode* ChoiceNode::FilterOneByte(int depth, bool ignore_case) {
+RegExpNode* ChoiceNode::FilterOneByte(intptr_t depth, bool ignore_case) {
   if (info()->replacement_calculated) return replacement();
   if (depth < 0) return this;
   if (info()->visited) return this;
   VisitMarker marker(info());
-  int choice_count = alternatives_->length();
+  intptr_t choice_count = alternatives_->length();
 
-  for (int i = 0; i < choice_count; i++) {
-    GuardedAlternative alternative = alternatives_->at(i);
+  for (intptr_t i = 0; i < choice_count; i++) {
+    GuardedAlternative alternative = alternatives_->At(i);
     if (alternative.guards() != NULL && alternative.guards()->length() != 0) {
       set_replacement(this);
       return this;
     }
   }
 
-  int surviving = 0;
+  intptr_t surviving = 0;
   RegExpNode* survivor = NULL;
-  for (int i = 0; i < choice_count; i++) {
-    GuardedAlternative alternative = alternatives_->at(i);
+  for (intptr_t i = 0; i < choice_count; i++) {
+    GuardedAlternative alternative = alternatives_->At(i);
     RegExpNode* replacement =
         alternative.node()->FilterOneByte(depth - 1, ignore_case);
-    DCHECK(replacement != this);  // No missing EMPTY_MATCH_CHECK.
+    ASSERT(replacement != this);  // No missing EMPTY_MATCH_CHECK.
     if (replacement != NULL) {
-      alternatives_->at(i).set_node(replacement);
+      (*alternatives_)[i].set_node(replacement);
       surviving++;
       survivor = replacement;
     }
@@ -2165,14 +2193,14 @@ RegExpNode* ChoiceNode::FilterOneByte(int depth, bool ignore_case) {
   }
   // Only some of the nodes survived the filtering.  We need to rebuild the
   // alternatives list.
-  ZoneList<GuardedAlternative>* new_alternatives =
-      new(zone()) ZoneList<GuardedAlternative>(surviving, zone());
-  for (int i = 0; i < choice_count; i++) {
+  ZoneGrowableArray<GuardedAlternative>* new_alternatives =
+      new(I) ZoneGrowableArray<GuardedAlternative>(surviving);
+  for (intptr_t i = 0; i < choice_count; i++) {
     RegExpNode* replacement =
-        alternatives_->at(i).node()->FilterOneByte(depth - 1, ignore_case);
+        (*alternatives_)[i].node()->FilterOneByte(depth - 1, ignore_case);
     if (replacement != NULL) {
-      alternatives_->at(i).set_node(replacement);
-      new_alternatives->Add(alternatives_->at(i), zone());
+      (*alternatives_)[i].set_node(replacement);
+      new_alternatives->Add((*alternatives_)[i]);
     }
   }
   alternatives_ = new_alternatives;
@@ -2180,7 +2208,7 @@ RegExpNode* ChoiceNode::FilterOneByte(int depth, bool ignore_case) {
 }
 
 
-RegExpNode* NegativeLookaheadChoiceNode::FilterOneByte(int depth,
+RegExpNode* NegativeLookaheadChoiceNode::FilterOneByte(intptr_t depth,
                                                        bool ignore_case) {
   if (info()->replacement_calculated) return replacement();
   if (depth < 0) return this;
@@ -2188,24 +2216,24 @@ RegExpNode* NegativeLookaheadChoiceNode::FilterOneByte(int depth,
   VisitMarker marker(info());
   // Alternative 0 is the negative lookahead, alternative 1 is what comes
   // afterwards.
-  RegExpNode* node = alternatives_->at(1).node();
+  RegExpNode* node = (*alternatives_)[1].node();
   RegExpNode* replacement = node->FilterOneByte(depth - 1, ignore_case);
   if (replacement == NULL) return set_replacement(NULL);
-  alternatives_->at(1).set_node(replacement);
+  (*alternatives_)[1].set_node(replacement);
 
-  RegExpNode* neg_node = alternatives_->at(0).node();
+  RegExpNode* neg_node = (*alternatives_)[0].node();
   RegExpNode* neg_replacement = neg_node->FilterOneByte(depth - 1, ignore_case);
   // If the negative lookahead is always going to fail then
   // we don't need to check it.
   if (neg_replacement == NULL) return set_replacement(replacement);
-  alternatives_->at(0).set_node(neg_replacement);
+  (*alternatives_)[0].set_node(neg_replacement);
   return set_replacement(this);
 }
 
 
 void LoopChoiceNode::GetQuickCheckDetails(QuickCheckDetails* details,
                                           RegExpCompiler* compiler,
-                                          int characters_filled_in,
+                                          intptr_t characters_filled_in,
                                           bool not_at_start) {
   if (body_can_be_zero_length_ || info()->visited) return;
   VisitMarker marker(info());
@@ -2216,8 +2244,8 @@ void LoopChoiceNode::GetQuickCheckDetails(QuickCheckDetails* details,
 }
 
 
-void LoopChoiceNode::FillInBMInfo(int offset,
-                                  int budget,
+void LoopChoiceNode::FillInBMInfo(intptr_t offset,
+                                  intptr_t budget,
                                   BoyerMooreLookahead* bm,
                                   bool not_at_start) {
   if (body_can_be_zero_length_ || budget <= 0) {
@@ -2232,18 +2260,18 @@ void LoopChoiceNode::FillInBMInfo(int offset,
 
 void ChoiceNode::GetQuickCheckDetails(QuickCheckDetails* details,
                                       RegExpCompiler* compiler,
-                                      int characters_filled_in,
+                                      intptr_t characters_filled_in,
                                       bool not_at_start) {
   not_at_start = (not_at_start || not_at_start_);
-  int choice_count = alternatives_->length();
-  DCHECK(choice_count > 0);
-  alternatives_->at(0).node()->GetQuickCheckDetails(details,
+  intptr_t choice_count = alternatives_->length();
+  ASSERT(choice_count > 0);
+  (*alternatives_)[0].node()->GetQuickCheckDetails(details,
                                                     compiler,
                                                     characters_filled_in,
                                                     not_at_start);
-  for (int i = 1; i < choice_count; i++) {
+  for (intptr_t i = 1; i < choice_count; i++) {
     QuickCheckDetails new_details(details->characters());
-    RegExpNode* node = alternatives_->at(i).node();
+    RegExpNode* node = (*alternatives_)[i].node();
     node->GetQuickCheckDetails(&new_details, compiler,
                                characters_filled_in,
                                not_at_start);
@@ -2255,8 +2283,8 @@ void ChoiceNode::GetQuickCheckDetails(QuickCheckDetails* details,
 
 // Check for [0-9A-Z_a-z].
 static void EmitWordCheck(RegExpMacroAssembler* assembler,
-                          Label* word,
-                          Label* non_word,
+                          BlockLabel* word,
+                          BlockLabel* non_word,
                           bool fall_through_on_word) {
   if (assembler->CheckSpecialCharacterClass(
           fall_through_on_word ? 'w' : 'W',
@@ -2289,7 +2317,7 @@ static void EmitHat(RegExpCompiler* compiler,
   Trace new_trace(*trace);
   new_trace.InvalidateCurrentCharacter();
 
-  Label ok;
+  BlockLabel ok;
   if (new_trace.cp_offset() == 0) {
     // The start of input counts as a newline in this context, so skip to
     // ok if we are at the start.
@@ -2309,7 +2337,7 @@ static void EmitHat(RegExpCompiler* compiler,
     assembler->CheckCharacter('\n', &ok);
     assembler->CheckNotCharacter('\r', new_trace.backtrack());
   }
-  assembler->Bind(&ok);
+  assembler->BindBlock(&ok);
   on_success->Emit(compiler, &new_trace);
 }
 
@@ -2321,13 +2349,14 @@ void AssertionNode::EmitBoundaryCheck(RegExpCompiler* compiler, Trace* trace) {
   bool not_at_start = (trace->at_start() == Trace::FALSE_VALUE);
   BoyerMooreLookahead* lookahead = bm_info(not_at_start);
   if (lookahead == NULL) {
-    int eats_at_least =
-        Min(kMaxLookaheadForBoyerMoore, EatsAtLeast(kMaxLookaheadForBoyerMoore,
-                                                    kRecursionBudget,
-                                                    not_at_start));
+    intptr_t eats_at_least =
+        Utils::Minimum(kMaxLookaheadForBoyerMoore,
+                       EatsAtLeast(kMaxLookaheadForBoyerMoore,
+                                   kRecursionBudget,
+                                   not_at_start));
     if (eats_at_least >= 1) {
       BoyerMooreLookahead* bm =
-          new(zone()) BoyerMooreLookahead(eats_at_least, compiler, zone());
+          new(I) BoyerMooreLookahead(eats_at_least, compiler, I);
       FillInBMInfo(0, kRecursionBudget, bm, not_at_start);
       if (bm->at(0)->is_non_word())
         next_is_word_character = Trace::FALSE_VALUE;
@@ -2341,26 +2370,31 @@ void AssertionNode::EmitBoundaryCheck(RegExpCompiler* compiler, Trace* trace) {
   }
   bool at_boundary = (assertion_type_ == AssertionNode::AT_BOUNDARY);
   if (next_is_word_character == Trace::UNKNOWN) {
-    Label before_non_word;
-    Label before_word;
+    BlockLabel before_non_word;
+    BlockLabel before_word;
     if (trace->characters_preloaded() != 1) {
       assembler->LoadCurrentCharacter(trace->cp_offset(), &before_non_word);
     }
     // Fall through on non-word.
     EmitWordCheck(assembler, &before_word, &before_non_word, false);
     // Next character is not a word character.
-    assembler->Bind(&before_non_word);
-    Label ok;
+    assembler->BindBlock(&before_non_word);
+    BlockLabel ok;
+    // Backtrack on \B (non-boundary check) if previous is a word,
+    // since we know next *is not* a word and this would be a boundary.
     BacktrackIfPrevious(compiler, trace, at_boundary ? kIsNonWord : kIsWord);
-    assembler->GoTo(&ok);
 
-    assembler->Bind(&before_word);
+    if (!assembler->IsClosed()) {
+      assembler->GoTo(&ok);
+    }
+
+    assembler->BindBlock(&before_word);
     BacktrackIfPrevious(compiler, trace, at_boundary ? kIsWord : kIsNonWord);
-    assembler->Bind(&ok);
+    assembler->BindBlock(&ok);
   } else if (next_is_word_character == Trace::TRUE_VALUE) {
     BacktrackIfPrevious(compiler, trace, at_boundary ? kIsWord : kIsNonWord);
   } else {
-    DCHECK(next_is_word_character == Trace::FALSE_VALUE);
+    ASSERT(next_is_word_character == Trace::FALSE_VALUE);
     BacktrackIfPrevious(compiler, trace, at_boundary ? kIsNonWord : kIsWord);
   }
 }
@@ -2374,14 +2408,14 @@ void AssertionNode::BacktrackIfPrevious(
   Trace new_trace(*trace);
   new_trace.InvalidateCurrentCharacter();
 
-  Label fall_through, dummy;
+  BlockLabel fall_through, dummy;
 
-  Label* non_word = backtrack_if_previous == kIsNonWord ?
-                    new_trace.backtrack() :
-                    &fall_through;
-  Label* word = backtrack_if_previous == kIsNonWord ?
-                &fall_through :
-                new_trace.backtrack();
+  BlockLabel* non_word = backtrack_if_previous == kIsNonWord ?
+                         new_trace.backtrack() :
+                         &fall_through;
+  BlockLabel* word = backtrack_if_previous == kIsNonWord ?
+                     &fall_through :
+                     new_trace.backtrack();
 
   if (new_trace.cp_offset() == 0) {
     // The start of input counts as a non-word character, so the question is
@@ -2393,14 +2427,14 @@ void AssertionNode::BacktrackIfPrevious(
   assembler->LoadCurrentCharacter(new_trace.cp_offset() - 1, &dummy, false);
   EmitWordCheck(assembler, word, non_word, backtrack_if_previous == kIsNonWord);
 
-  assembler->Bind(&fall_through);
+  assembler->BindBlock(&fall_through);
   on_success()->Emit(compiler, &new_trace);
 }
 
 
 void AssertionNode::GetQuickCheckDetails(QuickCheckDetails* details,
                                          RegExpCompiler* compiler,
-                                         int filled_in,
+                                         intptr_t filled_in,
                                          bool not_at_start) {
   if (assertion_type_ == AT_START && not_at_start) {
     details->set_cannot_match();
@@ -2417,10 +2451,10 @@ void AssertionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
   switch (assertion_type_) {
     case AT_END: {
-      Label ok;
+      BlockLabel ok;
       assembler->CheckPosition(trace->cp_offset(), &ok);
       assembler->GoTo(trace->backtrack());
-      assembler->Bind(&ok);
+      assembler->BindBlock(&ok);
       break;
     }
     case AT_START: {
@@ -2450,14 +2484,14 @@ void AssertionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
 }
 
 
-static bool DeterminedAlready(QuickCheckDetails* quick_check, int offset) {
+static bool DeterminedAlready(QuickCheckDetails* quick_check, intptr_t offset) {
   if (quick_check == NULL) return false;
   if (offset >= quick_check->characters()) return false;
   return quick_check->positions(offset)->determines_perfectly;
 }
 
 
-static void UpdateBoundsCheck(int index, int* checked_up_to) {
+static void UpdateBoundsCheck(intptr_t index, intptr_t* checked_up_to) {
   if (index > *checked_up_to) {
     *checked_up_to = index;
   }
@@ -2498,26 +2532,25 @@ void TextNode::TextEmitPass(RegExpCompiler* compiler,
                             bool preloaded,
                             Trace* trace,
                             bool first_element_checked,
-                            int* checked_up_to) {
+                            intptr_t* checked_up_to) {
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
-  Isolate* isolate = assembler->zone()->isolate();
   bool one_byte = compiler->one_byte();
-  Label* backtrack = trace->backtrack();
+  BlockLabel* 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();
+  intptr_t element_count = elms_->length();
+  for (intptr_t i = preloaded ? 0 : element_count - 1; i >= 0; i--) {
+    TextElement elm = elms_->At(i);
+    intptr_t cp_offset = trace->cp_offset() + elm.cp_offset();
     if (elm.text_type() == TextElement::ATOM) {
-      Vector<const uc16> quarks = elm.atom()->data();
-      for (int j = preloaded ? 0 : quarks.length() - 1; j >= 0; j--) {
+      ZoneGrowableArray<uint16_t>* quarks = elm.atom()->data();
+      for (intptr_t j = preloaded ? 0 : quarks->length() - 1; j >= 0; j--) {
         if (first_element_checked && i == 0 && j == 0) continue;
         if (DeterminedAlready(quick_check, elm.cp_offset() + j)) continue;
         EmitCharacterFunction* emit_function = NULL;
         switch (pass) {
           case NON_LATIN1_MATCH:
-            DCHECK(one_byte);
-            if (quarks[j] > String::kMaxOneByteCharCode) {
+            ASSERT(one_byte);
+            if (quarks->At(j) > Symbols::kMaxOneCharCodeSymbol) {
               assembler->GoTo(backtrack);
               return;
             }
@@ -2535,9 +2568,9 @@ void TextNode::TextEmitPass(RegExpCompiler* compiler,
             break;
         }
         if (emit_function != NULL) {
-          bool bound_checked = emit_function(isolate,
+          bool bound_checked = emit_function(I,
                                              compiler,
-                                             quarks[j],
+                                             quarks->At(j),
                                              backtrack,
                                              cp_offset + j,
                                              *checked_up_to < cp_offset + j,
@@ -2546,13 +2579,19 @@ void TextNode::TextEmitPass(RegExpCompiler* compiler,
         }
       }
     } else {
-      DCHECK_EQ(TextElement::CHAR_CLASS, elm.text_type());
+      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, zone());
+        EmitCharClass(assembler,
+                      cc,
+                      one_byte,
+                      backtrack,
+                      cp_offset,
+                      *checked_up_to < cp_offset,
+                      preloaded,
+                      I);
         UpdateBoundsCheck(cp_offset, checked_up_to);
       }
     }
@@ -2560,15 +2599,15 @@ void TextNode::TextEmitPass(RegExpCompiler* compiler,
 }
 
 
-int TextNode::Length() {
-  TextElement elm = elms_->last();
-  DCHECK(elm.cp_offset() >= 0);
+intptr_t TextNode::Length() {
+  TextElement elm = elms_->Last();
+  ASSERT(elm.cp_offset() >= 0);
   return elm.cp_offset() + elm.length();
 }
 
 
-bool TextNode::SkipPass(int int_pass, bool ignore_case) {
-  TextEmitPassType pass = static_cast<TextEmitPassType>(int_pass);
+bool TextNode::SkipPass(intptr_t intptr_t_pass, bool ignore_case) {
+  TextEmitPassType pass = static_cast<TextEmitPassType>(intptr_t_pass);
   if (ignore_case) {
     return pass == SIMPLE_CHARACTER_MATCH;
   } else {
@@ -2586,7 +2625,7 @@ bool TextNode::SkipPass(int int_pass, bool ignore_case) {
 void TextNode::Emit(RegExpCompiler* compiler, Trace* trace) {
   LimitResult limit_result = LimitVersions(compiler, trace);
   if (limit_result == DONE) return;
-  DCHECK(limit_result == CONTINUE);
+  ASSERT(limit_result == CONTINUE);
 
   if (trace->cp_offset() + Length() > RegExpMacroAssembler::kMaxCPOffset) {
     compiler->SetRegExpTooBig();
@@ -2594,18 +2633,18 @@ void TextNode::Emit(RegExpCompiler* compiler, Trace* trace) {
   }
 
   if (compiler->one_byte()) {
-    int dummy = 0;
+    intptr_t dummy = 0;
     TextEmitPass(compiler, NON_LATIN1_MATCH, false, trace, false, &dummy);
   }
 
   bool first_elt_done = false;
-  int bound_checked_to = trace->cp_offset() - 1;
+  intptr_t bound_checked_to = trace->cp_offset() - 1;
   bound_checked_to += trace->bound_checked_up_to();
 
   // If a character is preloaded into the current character register then
   // check that now.
   if (trace->characters_preloaded() == 1) {
-    for (int pass = kFirstRealPass; pass <= kLastPass; pass++) {
+    for (intptr_t pass = kFirstRealPass; pass <= kLastPass; pass++) {
       if (!SkipPass(pass, compiler->ignore_case())) {
         TextEmitPass(compiler,
                      static_cast<TextEmitPassType>(pass),
@@ -2618,7 +2657,7 @@ void TextNode::Emit(RegExpCompiler* compiler, Trace* trace) {
     first_elt_done = true;
   }
 
-  for (int pass = kFirstRealPass; pass <= kLastPass; pass++) {
+  for (intptr_t pass = kFirstRealPass; pass <= kLastPass; pass++) {
     if (!SkipPass(pass, compiler->ignore_case())) {
       TextEmitPass(compiler,
                    static_cast<TextEmitPassType>(pass),
@@ -2642,8 +2681,9 @@ void Trace::InvalidateCurrentCharacter() {
 }
 
 
-void Trace::AdvanceCurrentPositionInTrace(int by, RegExpCompiler* compiler) {
-  DCHECK(by > 0);
+void Trace::AdvanceCurrentPositionInTrace(intptr_t by,
+                                          RegExpCompiler* compiler) {
+  ASSERT(by > 0);
   // We don't have an instruction for shifting the current character register
   // down or for using a shifted value for anything so lets just forget that
   // we preloaded any characters into it.
@@ -2657,31 +2697,32 @@ void Trace::AdvanceCurrentPositionInTrace(int by, RegExpCompiler* compiler) {
     compiler->SetRegExpTooBig();
     cp_offset_ = 0;
   }
-  bound_checked_up_to_ = Max(0, bound_checked_up_to_ - by);
+  bound_checked_up_to_ = Utils::Maximum(static_cast<intptr_t>(0),
+                                        bound_checked_up_to_ - by);
 }
 
 
 void TextNode::MakeCaseIndependent(bool is_one_byte) {
-  int element_count = elms_->length();
-  for (int i = 0; i < element_count; i++) {
-    TextElement elm = elms_->at(i);
+  intptr_t element_count = elms_->length();
+  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(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_one_byte, zone());
+      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);
       }
     }
   }
 }
 
 
-int TextNode::GreedyLoopTextLength() {
-  TextElement elm = elms_->at(elms_->length() - 1);
+intptr_t TextNode::GreedyLoopTextLength() {
+  TextElement elm = elms_->At(elms_->length() - 1);
   return elm.cp_offset() + elm.length();
 }
 
@@ -2689,10 +2730,10 @@ int TextNode::GreedyLoopTextLength() {
 RegExpNode* TextNode::GetSuccessorOfOmnivorousTextNode(
     RegExpCompiler* compiler) {
   if (elms_->length() != 1) return NULL;
-  TextElement elm = elms_->at(0);
+  TextElement elm = elms_->At(0);
   if (elm.text_type() != TextElement::CHAR_CLASS) return NULL;
   RegExpCharacterClass* node = elm.char_class();
-  ZoneList<CharacterRange>* ranges = node->ranges(zone());
+  ZoneGrowableArray<CharacterRange>* ranges = node->ranges();
   if (!CharacterRange::IsCanonical(ranges)) {
     CharacterRange::Canonicalize(ranges);
   }
@@ -2702,11 +2743,11 @@ RegExpNode* TextNode::GetSuccessorOfOmnivorousTextNode(
   if (ranges->length() != 1) return NULL;
   uint32_t max_char;
   if (compiler->one_byte()) {
-    max_char = String::kMaxOneByteCharCode;
+    max_char = Symbols::kMaxOneCharCodeSymbol;
   } else {
-    max_char = String::kMaxUtf16CodeUnit;
+    max_char = Utf16::kMaxCodeUnit;
   }
-  return ranges->at(0).IsEverything(max_char) ? on_success() : NULL;
+  return ranges->At(0).IsEverything(max_char) ? on_success() : NULL;
 }
 
 
@@ -2714,18 +2755,18 @@ RegExpNode* TextNode::GetSuccessorOfOmnivorousTextNode(
 // this alternative and back to this choice node.  If there are variable
 // length nodes or other complications in the way then return a sentinel
 // value indicating that a greedy loop cannot be constructed.
-int ChoiceNode::GreedyLoopTextLengthForAlternative(
+intptr_t ChoiceNode::GreedyLoopTextLengthForAlternative(
     GuardedAlternative* alternative) {
-  int length = 0;
+  intptr_t length = 0;
   RegExpNode* node = alternative->node();
   // Later we will generate code for all these text nodes using recursion
   // so we have to limit the max number.
-  int recursion_depth = 0;
+  intptr_t recursion_depth = 0;
   while (node != this) {
     if (recursion_depth++ > RegExpCompiler::kMaxRecursion) {
       return kNodeIsTooComplexForGreedyLoops;
     }
-    int node_length = node->GreedyLoopTextLength();
+    intptr_t node_length = node->GreedyLoopTextLength();
     if (node_length == kNodeIsTooComplexForGreedyLoops) {
       return kNodeIsTooComplexForGreedyLoops;
     }
@@ -2738,14 +2779,14 @@ int ChoiceNode::GreedyLoopTextLengthForAlternative(
 
 
 void LoopChoiceNode::AddLoopAlternative(GuardedAlternative alt) {
-  DCHECK_EQ(loop_node_, NULL);
+  ASSERT(loop_node_ == NULL);
   AddAlternative(alt);
   loop_node_ = alt.node();
 }
 
 
 void LoopChoiceNode::AddContinueAlternative(GuardedAlternative alt) {
-  DCHECK_EQ(continue_node_, NULL);
+  ASSERT(continue_node_ == NULL);
   AddAlternative(alt);
   continue_node_ = alt.node();
 }
@@ -2755,17 +2796,17 @@ void LoopChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
   RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
   if (trace->stop_node() == this) {
     // Back edge of greedy optimized loop node graph.
-    int text_length =
-        GreedyLoopTextLengthForAlternative(&(alternatives_->at(0)));
-    DCHECK(text_length != kNodeIsTooComplexForGreedyLoops);
+    intptr_t text_length =
+        GreedyLoopTextLengthForAlternative(&((*alternatives_)[0]));
+    ASSERT(text_length != kNodeIsTooComplexForGreedyLoops);
     // Update the counter-based backtracking info on the stack.  This is an
     // optimization for greedy loops (see below).
-    DCHECK(trace->cp_offset() == text_length);
+    ASSERT(trace->cp_offset() == text_length);
     macro_assembler->AdvanceCurrentPosition(text_length);
     macro_assembler->GoTo(trace->loop_label());
     return;
   }
-  DCHECK(trace->stop_node() == NULL);
+  ASSERT(trace->stop_node() == NULL);
   if (!trace->is_trivial()) {
     trace->Flush(compiler, this);
     return;
@@ -2774,9 +2815,10 @@ void LoopChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
 }
 
 
-int ChoiceNode::CalculatePreloadCharacters(RegExpCompiler* compiler,
-                                           int eats_at_least) {
-  int preload_characters = Min(4, eats_at_least);
+intptr_t ChoiceNode::CalculatePreloadCharacters(RegExpCompiler* compiler,
+                                                intptr_t eats_at_least) {
+  intptr_t preload_characters = Utils::Minimum(static_cast<intptr_t>(4),
+                                               eats_at_least);
   if (compiler->macro_assembler()->CanReadUnaligned()) {
     bool one_byte = compiler->one_byte();
     if (one_byte) {
@@ -2795,18 +2837,17 @@ int ChoiceNode::CalculatePreloadCharacters(RegExpCompiler* compiler,
 }
 
 
-// This class is used when generating the alternatives in a choice node.  It
+// This structure is used when generating the alternatives in a choice node.  It
 // records the way the alternative is being code generated.
-class AlternativeGeneration: public Malloced {
- public:
+struct AlternativeGeneration {
   AlternativeGeneration()
       : possible_success(),
         expects_preload(false),
         after(),
         quick_check_details() { }
-  Label possible_success;
+  BlockLabel possible_success;
   bool expects_preload;
-  Label after;
+  BlockLabel after;
   QuickCheckDetails quick_check_details;
 };
 
@@ -2815,55 +2856,57 @@ class AlternativeGeneration: public Malloced {
 // size then it is on the stack, otherwise the excess is on the heap.
 class AlternativeGenerationList {
  public:
-  AlternativeGenerationList(int count, Zone* zone)
-      : alt_gens_(count, zone) {
-    for (int i = 0; i < count && i < kAFew; i++) {
-      alt_gens_.Add(a_few_alt_gens_ + i, zone);
+  explicit AlternativeGenerationList(intptr_t count)
+      : alt_gens_(count) {
+    for (intptr_t 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(), zone);
+    for (intptr_t i = kAFew; i < count; i++) {
+      alt_gens_.Add(new AlternativeGeneration());
     }
   }
   ~AlternativeGenerationList() {
-    for (int i = kAFew; i < alt_gens_.length(); i++) {
+    for (intptr_t i = kAFew; i < alt_gens_.length(); i++) {
       delete alt_gens_[i];
       alt_gens_[i] = NULL;
     }
   }
 
-  AlternativeGeneration* at(int i) {
+  AlternativeGeneration* at(intptr_t i) {
     return alt_gens_[i];
   }
 
  private:
-  static const int kAFew = 10;
-  ZoneList<AlternativeGeneration*> alt_gens_;
+  static const intptr_t kAFew = 10;
+  GrowableArray<AlternativeGeneration*> alt_gens_;
   AlternativeGeneration a_few_alt_gens_[kAFew];
+
+  DISALLOW_ALLOCATION();
 };
 
 
-// The '2' variant is has inclusive from and exclusive to.
+// The '2' variant is inclusive from and exclusive to.
 // This covers \s as defined in ECMA-262 5.1, 15.10.2.12,
 // which include WhiteSpace (7.2) or LineTerminator (7.3) values.
-static const int kSpaceRanges[] = { '\t', '\r' + 1, ' ', ' ' + 1,
+static const intptr_t kSpaceRanges[] = { '\t', '\r' + 1, ' ', ' ' + 1,
     0x00A0, 0x00A1, 0x1680, 0x1681, 0x180E, 0x180F, 0x2000, 0x200B,
     0x2028, 0x202A, 0x202F, 0x2030, 0x205F, 0x2060, 0x3000, 0x3001,
     0xFEFF, 0xFF00, 0x10000 };
-static const int kSpaceRangeCount = arraysize(kSpaceRanges);
-
-static const int kWordRanges[] = {
+static const intptr_t kSpaceRangeCount = ARRAY_SIZE(kSpaceRanges);
+static const intptr_t kWordRanges[] = {
     '0', '9' + 1, 'A', 'Z' + 1, '_', '_' + 1, 'a', 'z' + 1, 0x10000 };
-static const int kWordRangeCount = arraysize(kWordRanges);
-static const int kDigitRanges[] = { '0', '9' + 1, 0x10000 };
-static const int kDigitRangeCount = arraysize(kDigitRanges);
-static const int kSurrogateRanges[] = { 0xd800, 0xe000, 0x10000 };
-static const int kSurrogateRangeCount = arraysize(kSurrogateRanges);
-static const int kLineTerminatorRanges[] = { 0x000A, 0x000B, 0x000D, 0x000E,
-    0x2028, 0x202A, 0x10000 };
-static const int kLineTerminatorRangeCount = arraysize(kLineTerminatorRanges);
-
-
-void BoyerMoorePositionInfo::Set(int character) {
+static const intptr_t kWordRangeCount = ARRAY_SIZE(kWordRanges);
+static const intptr_t kDigitRanges[] = { '0', '9' + 1, 0x10000 };
+static const intptr_t kDigitRangeCount = ARRAY_SIZE(kDigitRanges);
+static const intptr_t kSurrogateRanges[] = { 0xd800, 0xe000, 0x10000 };
+static const intptr_t kSurrogateRangeCount = ARRAY_SIZE(kSurrogateRanges);
+static const intptr_t kLineTerminatorRanges[] = {
+    0x000A, 0x000B, 0x000D, 0x000E, 0x2028, 0x202A, 0x10000 };
+static const intptr_t kLineTerminatorRangeCount =
+    ARRAY_SIZE(kLineTerminatorRanges);
+
+
+void BoyerMoorePositionInfo::Set(intptr_t character) {
   SetInterval(Interval(character, character));
 }
 
@@ -2877,15 +2920,15 @@ void BoyerMoorePositionInfo::SetInterval(const Interval& interval) {
   if (interval.to() - interval.from() >= kMapSize - 1) {
     if (map_count_ != kMapSize) {
       map_count_ = kMapSize;
-      for (int i = 0; i < kMapSize; i++) map_->at(i) = true;
+      for (intptr_t i = 0; i < kMapSize; i++) (*map_)[i] = true;
     }
     return;
   }
-  for (int i = interval.from(); i <= interval.to(); i++) {
-    int mod_character = (i & kMask);
-    if (!map_->at(mod_character)) {
+  for (intptr_t i = interval.from(); i <= interval.to(); i++) {
+    intptr_t mod_character = (i & kMask);
+    if (!map_->At(mod_character)) {
       map_count_++;
-      map_->at(mod_character) = true;
+      (*map_)[mod_character] = true;
     }
     if (map_count_ == kMapSize) return;
   }
@@ -2896,23 +2939,23 @@ void BoyerMoorePositionInfo::SetAll() {
   s_ = w_ = d_ = kLatticeUnknown;
   if (map_count_ != kMapSize) {
     map_count_ = kMapSize;
-    for (int i = 0; i < kMapSize; i++) map_->at(i) = true;
+    for (intptr_t i = 0; i < kMapSize; i++) (*map_)[i] = true;
   }
 }
 
 
 BoyerMooreLookahead::BoyerMooreLookahead(
-    int length, RegExpCompiler* compiler, Zone* zone)
+    intptr_t length, RegExpCompiler* compiler, Isolate* isolate)
     : length_(length),
       compiler_(compiler) {
   if (compiler->one_byte()) {
-    max_char_ = String::kMaxOneByteCharCode;
+    max_char_ = Symbols::kMaxOneCharCodeSymbol;
   } else {
-    max_char_ = String::kMaxUtf16CodeUnit;
+    max_char_ = Utf16::kMaxCodeUnit;
   }
-  bitmaps_ = new(zone) ZoneList<BoyerMoorePositionInfo*>(length, zone);
-  for (int i = 0; i < length; i++) {
-    bitmaps_->Add(new(zone) BoyerMoorePositionInfo(zone), zone);
+  bitmaps_ = new(isolate) ZoneGrowableArray<BoyerMoorePositionInfo*>(length);
+  for (intptr_t i = 0; i < length; i++) {
+    bitmaps_->Add(new(isolate) BoyerMoorePositionInfo(isolate));
   }
 }
 
@@ -2920,12 +2963,12 @@ BoyerMooreLookahead::BoyerMooreLookahead(
 // 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(int* from, int* to) {
-  int biggest_points = 0;
+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
   // be lucky enough to step forwards much of the time.
-  const int kMaxMax = 32;
-  for (int max_number_of_chars = 4;
+  const intptr_t kMaxMax = 32;
+  for (intptr_t max_number_of_chars = 4;
        max_number_of_chars < kMaxMax;
        max_number_of_chars *= 2) {
     biggest_points =
@@ -2942,23 +2985,26 @@ bool BoyerMooreLookahead::FindWorthwhileInterval(int* from, int* to) {
 // of points as the product of width-of-the-range and
 // probability-of-finding-one-of-the-characters, where the probability is
 // calculated using the frequency distribution of the sample subject string.
-int BoyerMooreLookahead::FindBestInterval(
-    int max_number_of_chars, int old_biggest_points, int* from, int* to) {
-  int biggest_points = old_biggest_points;
-  static const int kSize = RegExpMacroAssembler::kTableSize;
-  for (int i = 0; i < length_; ) {
+intptr_t BoyerMooreLookahead::FindBestInterval(
+    intptr_t max_number_of_chars,
+    intptr_t old_biggest_points,
+    intptr_t* from,
+    intptr_t* to) {
+  intptr_t biggest_points = old_biggest_points;
+  static const intptr_t kSize = RegExpMacroAssembler::kTableSize;
+  for (intptr_t i = 0; i < length_; ) {
     while (i < length_ && Count(i) > max_number_of_chars) i++;
     if (i == length_) break;
-    int remembered_from = i;
+    intptr_t remembered_from = i;
     bool union_map[kSize];
-    for (int j = 0; j < kSize; j++) union_map[j] = false;
+    for (intptr_t j = 0; j < kSize; j++) union_map[j] = false;
     while (i < length_ && Count(i) <= max_number_of_chars) {
-      BoyerMoorePositionInfo* map = bitmaps_->at(i);
-      for (int j = 0; j < kSize; j++) union_map[j] |= map->at(j);
+      BoyerMoorePositionInfo* map = bitmaps_->At(i);
+      for (intptr_t j = 0; j < kSize; j++) union_map[j] |= map->at(j);
       i++;
     }
-    int frequency = 0;
-    for (int j = 0; j < kSize; j++) {
+    intptr_t frequency = 0;
+    for (intptr_t j = 0; j < kSize; j++) {
       if (union_map[j]) {
         // Add 1 to the frequency to give a small per-character boost for
         // the cases where our sampling is not good enough and many
@@ -2973,13 +3019,13 @@ int BoyerMooreLookahead::FindBestInterval(
     // dividing by 2 we switch off the skipping if the probability of skipping
     // is less than 50%.  This is because the multibyte mask-and-compare
     // skipping in quickcheck is more likely to do well on this case.
-    bool in_quickcheck_range =
-        ((i - remembered_from < 4) ||
-         (compiler_->one_byte() ? remembered_from <= 4 : remembered_from <= 2));
+    bool in_quickcheck_range = ((i - remembered_from < 4) ||
+        (compiler_->one_byte() ? remembered_from <= 4 : remembered_from <= 2));
     // Called 'probability' but it is only a rough estimate and can actually
     // be outside the 0-kSize range.
-    int probability = (in_quickcheck_range ? kSize / 2 : kSize) - frequency;
-    int points = (i - remembered_from) * probability;
+    intptr_t probability =
+        (in_quickcheck_range ? kSize / 2 : kSize) - frequency;
+    intptr_t points = (i - remembered_from) * probability;
     if (points > biggest_points) {
       *from = remembered_from;
       *to = i - 1;
@@ -2995,24 +3041,25 @@ int BoyerMooreLookahead::FindBestInterval(
 // max_lookahead (inclusive) measured from the current position.  If the
 // character at max_lookahead offset is not one of these characters, then we
 // can safely skip forwards by the number of characters in the range.
-int BoyerMooreLookahead::GetSkipTable(int min_lookahead,
-                                      int max_lookahead,
-                                      Handle<ByteArray> boolean_skip_table) {
-  const int kSize = RegExpMacroAssembler::kTableSize;
+intptr_t BoyerMooreLookahead::GetSkipTable(
+    intptr_t min_lookahead,
+    intptr_t max_lookahead,
+    const TypedData& boolean_skip_table) {
+  const intptr_t kSize = RegExpMacroAssembler::kTableSize;
 
-  const int kSkipArrayEntry = 0;
-  const int kDontSkipArrayEntry = 1;
+  const intptr_t kSkipArrayEntry = 0;
+  const intptr_t kDontSkipArrayEntry = 1;
 
-  for (int i = 0; i < kSize; i++) {
-    boolean_skip_table->set(i, kSkipArrayEntry);
+  for (intptr_t i = 0; i < kSize; i++) {
+    boolean_skip_table.SetUint8(i, kSkipArrayEntry);
   }
-  int skip = max_lookahead + 1 - min_lookahead;
+  intptr_t skip = max_lookahead + 1 - min_lookahead;
 
-  for (int i = max_lookahead; i >= min_lookahead; i--) {
-    BoyerMoorePositionInfo* map = bitmaps_->at(i);
-    for (int j = 0; j < kSize; j++) {
+  for (intptr_t i = max_lookahead; i >= min_lookahead; i--) {
+    BoyerMoorePositionInfo* map = bitmaps_->At(i);
+    for (intptr_t j = 0; j < kSize; j++) {
       if (map->at(j)) {
-        boolean_skip_table->set(j, kDontSkipArrayEntry);
+        boolean_skip_table.SetUint8(j, kDontSkipArrayEntry);
       }
     }
   }
@@ -3023,23 +3070,23 @@ int BoyerMooreLookahead::GetSkipTable(int min_lookahead,
 
 // See comment above on the implementation of GetSkipTable.
 void BoyerMooreLookahead::EmitSkipInstructions(RegExpMacroAssembler* masm) {
-  const int kSize = RegExpMacroAssembler::kTableSize;
+  const intptr_t kSize = RegExpMacroAssembler::kTableSize;
 
-  int min_lookahead = 0;
-  int max_lookahead = 0;
+  intptr_t min_lookahead = 0;
+  intptr_t max_lookahead = 0;
 
   if (!FindWorthwhileInterval(&min_lookahead, &max_lookahead)) return;
 
   bool found_single_character = false;
-  int single_character = 0;
-  for (int i = max_lookahead; i >= min_lookahead; i--) {
-    BoyerMoorePositionInfo* map = bitmaps_->at(i);
+  intptr_t single_character = 0;
+  for (intptr_t i = max_lookahead; i >= min_lookahead; i--) {
+    BoyerMoorePositionInfo* map = bitmaps_->At(i);
     if (map->map_count() > 1 ||
         (found_single_character && map->map_count() != 0)) {
       found_single_character = false;
       break;
     }
-    for (int j = 0; j < kSize; j++) {
+    for (intptr_t j = 0; j < kSize; j++) {
       if (map->at(j)) {
         found_single_character = true;
         single_character = j;
@@ -3048,7 +3095,7 @@ void BoyerMooreLookahead::EmitSkipInstructions(RegExpMacroAssembler* masm) {
     }
   }
 
-  int lookahead_width = max_lookahead + 1 - min_lookahead;
+  intptr_t lookahead_width = max_lookahead + 1 - min_lookahead;
 
   if (found_single_character && lookahead_width == 1 && max_lookahead < 3) {
     // The mask-compare can probably handle this better.
@@ -3056,8 +3103,8 @@ void BoyerMooreLookahead::EmitSkipInstructions(RegExpMacroAssembler* masm) {
   }
 
   if (found_single_character) {
-    Label cont, again;
-    masm->Bind(&again);
+    BlockLabel cont, again;
+    masm->BindBlock(&again);
     masm->LoadCurrentCharacter(max_lookahead, &cont, true);
     if (max_char_ > kSize) {
       masm->CheckCharacterAfterAnd(single_character,
@@ -3068,23 +3115,27 @@ void BoyerMooreLookahead::EmitSkipInstructions(RegExpMacroAssembler* masm) {
     }
     masm->AdvanceCurrentPosition(lookahead_width);
     masm->GoTo(&again);
-    masm->Bind(&cont);
+    masm->BindBlock(&cont);
     return;
   }
 
-  Factory* factory = masm->zone()->isolate()->factory();
-  Handle<ByteArray> boolean_skip_table = factory->NewByteArray(kSize, TENURED);
-  int skip_distance = GetSkipTable(
+  const TypedData& boolean_skip_table = TypedData::ZoneHandle(
+        compiler_->isolate(),
+        TypedData::New(kTypedDataUint8ArrayCid, kSize, Heap::kOld));
+  intptr_t skip_distance = GetSkipTable(
       min_lookahead, max_lookahead, boolean_skip_table);
-  DCHECK(skip_distance != 0);
+  ASSERT(skip_distance != 0);
 
-  Label cont, again;
-  masm->Bind(&again);
+  BlockLabel cont, again;
+
+  masm->BindBlock(&again);
   masm->LoadCurrentCharacter(max_lookahead, &cont, true);
   masm->CheckBitInTable(boolean_skip_table, &cont);
   masm->AdvanceCurrentPosition(skip_distance);
   masm->GoTo(&again);
-  masm->Bind(&cont);
+  masm->BindBlock(&cont);
+
+  return;
 }
 
 
@@ -3170,13 +3221,13 @@ GreedyLoopState::GreedyLoopState(bool not_at_start) {
 
 void ChoiceNode::AssertGuardsMentionRegisters(Trace* trace) {
 #ifdef DEBUG
-  int choice_count = alternatives_->length();
-  for (int i = 0; i < choice_count - 1; i++) {
-    GuardedAlternative alternative = alternatives_->at(i);
-    ZoneList<Guard*>* guards = alternative.guards();
-    int guard_count = (guards == NULL) ? 0 : guards->length();
-    for (int j = 0; j < guard_count; j++) {
-      DCHECK(!trace->mentions_reg(guards->at(j)->reg()));
+  intptr_t choice_count = alternatives_->length();
+  for (intptr_t i = 0; i < choice_count - 1; i++) {
+    GuardedAlternative alternative = alternatives_->At(i);
+    ZoneGrowableArray<Guard*>* guards = alternative.guards();
+    intptr_t guard_count = (guards == NULL) ? 0 : guards->length();
+    for (intptr_t j = 0; j < guard_count; j++) {
+      ASSERT(!trace->mentions_reg(guards->At(j)->reg()));
     }
   }
 #endif
@@ -3202,13 +3253,13 @@ void ChoiceNode::SetUpPreLoad(RegExpCompiler* compiler,
 
 
 void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
-  int choice_count = alternatives_->length();
+  intptr_t choice_count = alternatives_->length();
 
   AssertGuardsMentionRegisters(trace);
 
   LimitResult limit_result = LimitVersions(compiler, trace);
   if (limit_result == DONE) return;
-  DCHECK(limit_result == CONTINUE);
+  ASSERT(limit_result == CONTINUE);
 
   // For loop nodes we already flushed (see LoopChoiceNode::Emit), but for
   // other choice nodes we only flush if we are out of code size budget.
@@ -3223,8 +3274,9 @@ void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
   preload.init();
   GreedyLoopState greedy_loop_state(not_at_start());
 
-  int text_length = GreedyLoopTextLengthForAlternative(&alternatives_->at(0));
-  AlternativeGenerationList alt_gens(choice_count, zone());
+  intptr_t text_length =
+      GreedyLoopTextLengthForAlternative(&((*alternatives_)[0]));
+  AlternativeGenerationList alt_gens(choice_count);
 
   if (choice_count > 1 && text_length != kNodeIsTooComplexForGreedyLoops) {
     trace = EmitGreedyLoop(compiler,
@@ -3236,8 +3288,8 @@ void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
   } else {
     // TODO(erikcorry): Delete this.  We don't need this label, but it makes us
     // match the traces produced pre-cleanup.
-    Label second_choice;
-    compiler->macro_assembler()->Bind(&second_choice);
+    BlockLabel second_choice;
+    compiler->macro_assembler()->BindBlock(&second_choice);
 
     preload.eats_at_least_ = EmitOptimizedUnanchoredSearch(compiler, trace);
 
@@ -3251,8 +3303,8 @@ void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
   // At this point we need to generate slow checks for the alternatives where
   // the quick check was inlined.  We can recognize these because the associated
   // label was bound.
-  int new_flush_budget = trace->flush_budget() / choice_count;
-  for (int i = 0; i < choice_count; i++) {
+  intptr_t new_flush_budget = trace->flush_budget() / choice_count;
+  for (intptr_t i = 0; i < choice_count; i++) {
     AlternativeGeneration* alt_gen = alt_gens.at(i);
     Trace new_trace(*trace);
     // If there are actions to be flushed we have to limit how many times
@@ -3265,20 +3317,19 @@ void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
         i == choice_count - 1 ? false : alt_gens.at(i + 1)->expects_preload;
     EmitOutOfLineContinuation(compiler,
                               &new_trace,
-                              alternatives_->at(i),
+                              alternatives_->At(i),
                               alt_gen,
                               preload.preload_characters_,
                               next_expects_preload);
   }
 }
 
-
 Trace* ChoiceNode::EmitGreedyLoop(RegExpCompiler* compiler,
                                   Trace* trace,
                                   AlternativeGenerationList* alt_gens,
                                   PreloadState* preload,
                                   GreedyLoopState* greedy_loop_state,
-                                  int text_length) {
+                                  intptr_t text_length) {
   RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
   // Here we have special handling for greedy loops containing only text nodes
   // and other simple nodes.  These are handled by pushing the current
@@ -3287,21 +3338,21 @@ Trace* ChoiceNode::EmitGreedyLoop(RegExpCompiler* compiler,
   // and check it against the pushed value.  This avoids pushing backtrack
   // information for each iteration of the loop, which could take up a lot of
   // space.
-  DCHECK(trace->stop_node() == NULL);
+  ASSERT(trace->stop_node() == NULL);
   macro_assembler->PushCurrentPosition();
-  Label greedy_match_failed;
+  BlockLabel greedy_match_failed;
   Trace greedy_match_trace;
   if (not_at_start()) greedy_match_trace.set_at_start(false);
   greedy_match_trace.set_backtrack(&greedy_match_failed);
-  Label loop_label;
-  macro_assembler->Bind(&loop_label);
+  BlockLabel loop_label;
+  macro_assembler->BindBlock(&loop_label);
   greedy_match_trace.set_stop_node(this);
   greedy_match_trace.set_loop_label(&loop_label);
-  alternatives_->at(0).node()->Emit(compiler, &greedy_match_trace);
-  macro_assembler->Bind(&greedy_match_failed);
+  (*alternatives_)[0].node()->Emit(compiler, &greedy_match_trace);
+  macro_assembler->BindBlock(&greedy_match_failed);
 
-  Label second_choice;  // For use in greedy matches.
-  macro_assembler->Bind(&second_choice);
+  BlockLabel second_choice;  // For use in greedy matches.
+  macro_assembler->BindBlock(&second_choice);
 
   Trace* new_trace = greedy_loop_state->counter_backtrack_trace();
 
@@ -3311,7 +3362,7 @@ Trace* ChoiceNode::EmitGreedyLoop(RegExpCompiler* compiler,
               new_trace,
               preload);
 
-  macro_assembler->Bind(greedy_loop_state->label());
+  macro_assembler->BindBlock(greedy_loop_state->label());
   // If we have unwound to the bottom then backtrack.
   macro_assembler->CheckGreedyLoop(trace->backtrack());
   // Otherwise try the second priority at an earlier position.
@@ -3320,12 +3371,13 @@ Trace* ChoiceNode::EmitGreedyLoop(RegExpCompiler* compiler,
   return new_trace;
 }
 
-int ChoiceNode::EmitOptimizedUnanchoredSearch(RegExpCompiler* compiler,
-                                              Trace* trace) {
-  int eats_at_least = PreloadState::kEatsAtLeastNotYetInitialized;
+
+intptr_t ChoiceNode::EmitOptimizedUnanchoredSearch(RegExpCompiler* compiler,
+                                                   Trace* trace) {
+  intptr_t eats_at_least = PreloadState::kEatsAtLeastNotYetInitialized;
   if (alternatives_->length() != 2) return eats_at_least;
 
-  GuardedAlternative alt1 = alternatives_->at(1);
+  GuardedAlternative alt1 = alternatives_->At(1);
   if (alt1.guards() != NULL && alt1.guards()->length() != 0) {
     return eats_at_least;
   }
@@ -3340,7 +3392,7 @@ int ChoiceNode::EmitOptimizedUnanchoredSearch(RegExpCompiler* compiler,
   // loop.  That also implies that there are no preloaded characters, which is
   // good, because it means we won't be violating any assumptions by
   // overwriting those characters with new load instructions.
-  DCHECK(trace->is_trivial());
+  ASSERT(trace->is_trivial());
 
   RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
   // At this point we know that we are at a non-greedy loop that will eat
@@ -3352,15 +3404,13 @@ int ChoiceNode::EmitOptimizedUnanchoredSearch(RegExpCompiler* compiler,
   // small alternation.
   BoyerMooreLookahead* bm = bm_info(false);
   if (bm == NULL) {
-    eats_at_least = Min(kMaxLookaheadForBoyerMoore,
+    eats_at_least = Utils::Minimum(kMaxLookaheadForBoyerMoore,
                         EatsAtLeast(kMaxLookaheadForBoyerMoore,
                                     kRecursionBudget,
                                     false));
     if (eats_at_least >= 1) {
-      bm = new(zone()) BoyerMooreLookahead(eats_at_least,
-                                           compiler,
-                                           zone());
-      GuardedAlternative alt0 = alternatives_->at(0);
+      bm = new(I) BoyerMooreLookahead(eats_at_least, compiler, I);
+      GuardedAlternative alt0 = alternatives_->At(0);
       alt0.node()->FillInBMInfo(0, kRecursionBudget, bm, false);
     }
   }
@@ -3373,7 +3423,7 @@ int ChoiceNode::EmitOptimizedUnanchoredSearch(RegExpCompiler* compiler,
 
 void ChoiceNode::EmitChoices(RegExpCompiler* compiler,
                              AlternativeGenerationList* alt_gens,
-                             int first_choice,
+                             intptr_t first_choice,
                              Trace* trace,
                              PreloadState* preload) {
   RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
@@ -3381,18 +3431,18 @@ void ChoiceNode::EmitChoices(RegExpCompiler* compiler,
 
   // 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.
-  int choice_count = alternatives_->length();
+  intptr_t choice_count = alternatives_->length();
 
-  int new_flush_budget = trace->flush_budget() / choice_count;
+  intptr_t new_flush_budget = trace->flush_budget() / choice_count;
 
-  for (int i = first_choice; i < choice_count; i++) {
+  for (intptr_t i = first_choice; i < choice_count; i++) {
     bool is_last = i == choice_count - 1;
     bool fall_through_on_failure = !is_last;
-    GuardedAlternative alternative = alternatives_->at(i);
+    GuardedAlternative alternative = alternatives_->At(i);
     AlternativeGeneration* alt_gen = alt_gens->at(i);
     alt_gen->quick_check_details.set_characters(preload->preload_characters_);
-    ZoneList<Guard*>* guards = alternative.guards();
-    int guard_count = (guards == NULL) ? 0 : guards->length();
+    ZoneGrowableArray<Guard*>* guards = alternative.guards();
+    intptr_t guard_count = (guards == NULL) ? 0 : guards->length();
     Trace new_trace(*trace);
     new_trace.set_characters_preloaded(preload->preload_is_current_ ?
                                          preload->preload_characters_ :
@@ -3407,7 +3457,7 @@ void ChoiceNode::EmitChoices(RegExpCompiler* compiler,
     }
     alt_gen->expects_preload = preload->preload_is_current_;
     bool generate_full_check_inline = false;
-    if (FLAG_regexp_optimization &&
+    if (kRegexpOptimization &&
         try_to_emit_quick_check_for_alternative(i == 0) &&
         alternative.node()->EmitQuickCheck(compiler,
                                            trace,
@@ -3422,7 +3472,7 @@ void ChoiceNode::EmitChoices(RegExpCompiler* compiler,
       // If we generated the quick check to fall through on possible success,
       // we now need to generate the full check inline.
       if (!fall_through_on_failure) {
-        macro_assembler->Bind(&alt_gen->possible_success);
+        macro_assembler->BindBlock(&alt_gen->possible_success);
         new_trace.set_quick_check_performed(&alt_gen->quick_check_details);
         new_trace.set_characters_preloaded(preload->preload_characters_);
         new_trace.set_bound_checked_up_to(preload->preload_characters_);
@@ -3449,13 +3499,13 @@ void ChoiceNode::EmitChoices(RegExpCompiler* compiler,
       if (new_trace.actions() != NULL) {
         new_trace.set_flush_budget(new_flush_budget);
       }
-      for (int j = 0; j < guard_count; j++) {
-        GenerateGuard(macro_assembler, guards->at(j), &new_trace);
+      for (intptr_t j = 0; j < guard_count; j++) {
+        GenerateGuard(macro_assembler, guards->At(j), &new_trace);
       }
       alternative.node()->Emit(compiler, &new_trace);
       preload->preload_is_current_ = false;
     }
-    macro_assembler->Bind(&alt_gen->after);
+    macro_assembler->BindBlock(&alt_gen->after);
   }
 }
 
@@ -3464,26 +3514,26 @@ void ChoiceNode::EmitOutOfLineContinuation(RegExpCompiler* compiler,
                                            Trace* trace,
                                            GuardedAlternative alternative,
                                            AlternativeGeneration* alt_gen,
-                                           int preload_characters,
+                                           intptr_t preload_characters,
                                            bool next_expects_preload) {
-  if (!alt_gen->possible_success.is_linked()) return;
+  if (!alt_gen->possible_success.IsLinked()) return;
 
   RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
-  macro_assembler->Bind(&alt_gen->possible_success);
+  macro_assembler->BindBlock(&alt_gen->possible_success);
   Trace out_of_line_trace(*trace);
   out_of_line_trace.set_characters_preloaded(preload_characters);
   out_of_line_trace.set_quick_check_performed(&alt_gen->quick_check_details);
   if (not_at_start_) out_of_line_trace.set_at_start(Trace::FALSE_VALUE);
-  ZoneList<Guard*>* guards = alternative.guards();
-  int guard_count = (guards == NULL) ? 0 : guards->length();
+  ZoneGrowableArray<Guard*>* guards = alternative.guards();
+  intptr_t guard_count = (guards == NULL) ? 0 : guards->length();
   if (next_expects_preload) {
-    Label reload_current_char;
+    BlockLabel reload_current_char;
     out_of_line_trace.set_backtrack(&reload_current_char);
-    for (int j = 0; j < guard_count; j++) {
-      GenerateGuard(macro_assembler, guards->at(j), &out_of_line_trace);
+    for (intptr_t j = 0; j < guard_count; j++) {
+      GenerateGuard(macro_assembler, guards->At(j), &out_of_line_trace);
     }
     alternative.node()->Emit(compiler, &out_of_line_trace);
-    macro_assembler->Bind(&reload_current_char);
+    macro_assembler->BindBlock(&reload_current_char);
     // Reload the current character, since the next quick check expects that.
     // We don't need to check bounds here because we only get into this
     // code through a quick check which already did the checked load.
@@ -3494,8 +3544,8 @@ void ChoiceNode::EmitOutOfLineContinuation(RegExpCompiler* compiler,
     macro_assembler->GoTo(&(alt_gen->after));
   } else {
     out_of_line_trace.set_backtrack(&(alt_gen->after));
-    for (int j = 0; j < guard_count; j++) {
-      GenerateGuard(macro_assembler, guards->at(j), &out_of_line_trace);
+    for (intptr_t j = 0; j < guard_count; j++) {
+      GenerateGuard(macro_assembler, guards->At(j), &out_of_line_trace);
     }
     alternative.node()->Emit(compiler, &out_of_line_trace);
   }
@@ -3506,7 +3556,7 @@ void ActionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
   LimitResult limit_result = LimitVersions(compiler, trace);
   if (limit_result == DONE) return;
-  DCHECK(limit_result == CONTINUE);
+  ASSERT(limit_result == CONTINUE);
 
   RecursionCheck rc(compiler);
 
@@ -3558,9 +3608,9 @@ void ActionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
       }
       break;
     case EMPTY_MATCH_CHECK: {
-      int start_pos_reg = data_.u_empty_match_check.start_register;
-      int stored_pos = 0;
-      int rep_reg = data_.u_empty_match_check.repetition_register;
+      intptr_t start_pos_reg = data_.u_empty_match_check.start_register;
+      intptr_t stored_pos = 0;
+      intptr_t rep_reg = data_.u_empty_match_check.repetition_register;
       bool has_minimum = (rep_reg != RegExpCompiler::kNoRegister);
       bool know_dist = trace->GetStoredPosition(start_pos_reg, &stored_pos);
       if (know_dist && !has_minimum && stored_pos == trace->cp_offset()) {
@@ -3574,18 +3624,18 @@ void ActionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
       } else if (!trace->is_trivial()) {
         trace->Flush(compiler, this);
       } else {
-        Label skip_empty_check;
+        BlockLabel skip_empty_check;
         // If we have a minimum number of repetitions we check the current
         // number first and skip the empty check if it's not enough.
         if (has_minimum) {
-          int limit = data_.u_empty_match_check.repetition_limit;
+          intptr_t limit = data_.u_empty_match_check.repetition_limit;
           assembler->IfRegisterLT(rep_reg, limit, &skip_empty_check);
         }
         // If the match is empty we bail out, otherwise we fall through
         // to the on-success continuation.
         assembler->IfRegisterEqPos(data_.u_empty_match_check.start_register,
                                    trace->backtrack());
-        assembler->Bind(&skip_empty_check);
+        assembler->BindBlock(&skip_empty_check);
         on_success()->Emit(compiler, trace);
       }
       break;
@@ -3599,22 +3649,23 @@ void ActionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
           data_.u_submatch.current_position_register);
       assembler->ReadStackPointerFromRegister(
           data_.u_submatch.stack_pointer_register);
-      int clear_register_count = data_.u_submatch.clear_register_count;
+      intptr_t clear_register_count = data_.u_submatch.clear_register_count;
       if (clear_register_count == 0) {
         on_success()->Emit(compiler, trace);
         return;
       }
-      int clear_registers_from = data_.u_submatch.clear_register_from;
-      Label clear_registers_backtrack;
+      intptr_t clear_registers_from = data_.u_submatch.clear_register_from;
+      BlockLabel clear_registers_backtrack;
       Trace new_trace = *trace;
       new_trace.set_backtrack(&clear_registers_backtrack);
       on_success()->Emit(compiler, &new_trace);
 
-      assembler->Bind(&clear_registers_backtrack);
-      int clear_registers_to = clear_registers_from + clear_register_count - 1;
+      assembler->BindBlock(&clear_registers_backtrack);
+      intptr_t clear_registers_to =
+          clear_registers_from + clear_register_count - 1;
       assembler->ClearRegisters(clear_registers_from, clear_registers_to);
 
-      DCHECK(trace->backtrack() == NULL);
+      ASSERT(trace->backtrack() == NULL);
       assembler->Backtrack();
       return;
     }
@@ -3633,11 +3684,11 @@ void BackReferenceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
 
   LimitResult limit_result = LimitVersions(compiler, trace);
   if (limit_result == DONE) return;
-  DCHECK(limit_result == CONTINUE);
+  ASSERT(limit_result == CONTINUE);
 
   RecursionCheck rc(compiler);
 
-  DCHECK_EQ(start_reg_ + 1, end_reg_);
+  ASSERT(start_reg_ + 1 == end_reg_);
   if (compiler->ignore_case()) {
     assembler->CheckNotBackReferenceIgnoreCase(start_reg_,
                                                trace->backtrack());
@@ -3657,9 +3708,8 @@ void BackReferenceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
 
 class DotPrinter: public NodeVisitor {
  public:
-  DotPrinter(OStream& os, bool ignore_case)  // NOLINT
-      : os_(os),
-        ignore_case_(ignore_case) {}
+  explicit DotPrinter(bool ignore_case)
+      : ignore_case_(ignore_case) {}
   void PrintNode(const char* label, RegExpNode* node);
   void Visit(RegExpNode* node);
   void PrintAttributes(RegExpNode* from);
@@ -3669,29 +3719,28 @@ class DotPrinter: public NodeVisitor {
 FOR_EACH_NODE_TYPE(DECLARE_VISIT)
 #undef DECLARE_VISIT
  private:
-  OStream& os_;
   bool ignore_case_;
 };
 
 
 void DotPrinter::PrintNode(const char* label, RegExpNode* node) {
-  os_ << "digraph G {\n  graph [label=\"";
-  for (int i = 0; label[i]; i++) {
+  OS::Print("digraph G {\n  graph [label=\"");
+  for (intptr_t i = 0; label[i]; i++) {
     switch (label[i]) {
       case '\\':
-        os_ << "\\\\";
+        OS::Print("\\\\");
         break;
       case '"':
-        os_ << "\"";
+        OS::Print("\"");
         break;
       default:
-        os_ << label[i];
+        OS::Print("%c", label[i]);
         break;
     }
   }
-  os_ << "\"];\n";
+  OS::Print("\"];\n");
   Visit(node);
-  os_ << "}" << endl;
+  OS::Print("}\n");
 }
 
 
@@ -3703,292 +3752,194 @@ void DotPrinter::Visit(RegExpNode* node) {
 
 
 void DotPrinter::PrintOnFailure(RegExpNode* from, RegExpNode* on_failure) {
-  os_ << "  n" << from << " -> n" << on_failure << " [style=dotted];\n";
+  OS::Print("  n%p -> n%p [style=dotted];\n", from, on_failure);
   Visit(on_failure);
 }
 
 
-class TableEntryBodyPrinter {
+class AttributePrinter : public ValueObject {
  public:
-  TableEntryBodyPrinter(OStream& os, ChoiceNode* choice)  // NOLINT
-      : os_(os),
-        choice_(choice) {}
-  void Call(uc16 from, DispatchTable::Entry entry) {
-    OutSet* out_set = entry.out_set();
-    for (unsigned i = 0; i < OutSet::kFirstLimit; i++) {
-      if (out_set->Get(i)) {
-        os_ << "    n" << choice() << ":s" << from << "o" << i << " -> n"
-            << choice()->alternatives()->at(i).node() << ";\n";
-      }
-    }
-  }
- private:
-  ChoiceNode* choice() { return choice_; }
-  OStream& os_;
-  ChoiceNode* choice_;
-};
-
-
-class TableEntryHeaderPrinter {
- public:
-  explicit TableEntryHeaderPrinter(OStream& os)  // NOLINT
-      : first_(true),
-        os_(os) {}
-  void Call(uc16 from, DispatchTable::Entry entry) {
-    if (first_) {
-      first_ = false;
-    } else {
-      os_ << "|";
-    }
-    os_ << "{\\" << AsUC16(from) << "-\\" << AsUC16(entry.to()) << "|{";
-    OutSet* out_set = entry.out_set();
-    int priority = 0;
-    for (unsigned i = 0; i < OutSet::kFirstLimit; i++) {
-      if (out_set->Get(i)) {
-        if (priority > 0) os_ << "|";
-        os_ << "<s" << from << "o" << i << "> " << priority;
-        priority++;
-      }
-    }
-    os_ << "}}";
-  }
-
- private:
-  bool first_;
-  OStream& os_;
-};
-
-
-class AttributePrinter {
- public:
-  explicit AttributePrinter(OStream& os)  // NOLINT
-      : os_(os),
-        first_(true) {}
+  AttributePrinter() : first_(true) {}
   void PrintSeparator() {
     if (first_) {
       first_ = false;
     } else {
-      os_ << "|";
+      OS::Print("|");
     }
   }
   void PrintBit(const char* name, bool value) {
     if (!value) return;
     PrintSeparator();
-    os_ << "{" << name << "}";
+    OS::Print("{%s}", name);
   }
-  void PrintPositive(const char* name, int value) {
+  void PrintPositive(const char* name, intptr_t value) {
     if (value < 0) return;
     PrintSeparator();
-    os_ << "{" << name << "|" << value << "}";
+    OS::Print("{%s|%" Pd "}", name, value);
   }
 
  private:
-  OStream& os_;
   bool first_;
 };
 
 
 void DotPrinter::PrintAttributes(RegExpNode* that) {
-  os_ << "  a" << that << " [shape=Mrecord, color=grey, fontcolor=grey, "
-      << "margin=0.1, fontsize=10, label=\"{";
-  AttributePrinter printer(os_);
+  OS::Print("  a%p [shape=Mrecord, color=grey, fontcolor=grey, "
+            "margin=0.1, fontsize=10, label=\"{", that);
+  AttributePrinter printer;
   NodeInfo* info = that->info();
   printer.PrintBit("NI", info->follows_newline_interest);
   printer.PrintBit("WI", info->follows_word_interest);
   printer.PrintBit("SI", info->follows_start_interest);
-  Label* label = that->label();
-  if (label->is_bound())
-    printer.PrintPositive("@", label->pos());
-  os_ << "}\"];\n"
-      << "  a" << that << " -> n" << that
-      << " [style=dashed, color=grey, arrowhead=none];\n";
+  BlockLabel* label = that->label();
+  if (label->IsBound())
+    printer.PrintPositive("@", label->Position());
+  OS::Print("}\"];\n"
+            "  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) {
-    os_ << "  n" << that << " [shape=Mrecord, label=\"";
-    TableEntryHeaderPrinter header_printer(os_);
-    that->GetTable(ignore_case_)->ForEach(&header_printer);
-    os_ << "\"]\n";
-    PrintAttributes(that);
-    TableEntryBodyPrinter body_printer(os_, that);
-    that->GetTable(ignore_case_)->ForEach(&body_printer);
-  } else {
-    os_ << "  n" << that << " [shape=Mrecord, label=\"?\"];\n";
-    for (int i = 0; i < that->alternatives()->length(); i++) {
-      GuardedAlternative alt = that->alternatives()->at(i);
-      os_ << "  n" << that << " -> n" << alt.node();
-    }
+  OS::Print("  n%p [shape=Mrecord, label=\"?\"];\n", that);
+  for (intptr_t i = 0; i < that->alternatives()->length(); i++) {
+    GuardedAlternative alt = that->alternatives()->At(i);
+    OS::Print("  n%p -> n%p", that, alt.node());
   }
-  for (int i = 0; i < that->alternatives()->length(); i++) {
-    GuardedAlternative alt = that->alternatives()->at(i);
+  for (intptr_t i = 0; i < that->alternatives()->length(); i++) {
+    GuardedAlternative alt = that->alternatives()->At(i);
     alt.node()->Accept(this);
   }
 }
 
 
 void DotPrinter::VisitText(TextNode* that) {
-  Zone* zone = that->zone();
-  os_ << "  n" << that << " [label=\"";
-  for (int i = 0; i < that->elements()->length(); i++) {
-    if (i > 0) os_ << " ";
-    TextElement elm = that->elements()->at(i);
+  OS::Print("  n%p [label=\"", that);
+  for (intptr_t i = 0; i < that->elements()->length(); i++) {
+    if (i > 0) OS::Print(" ");
+    TextElement elm = that->elements()->At(i);
     switch (elm.text_type()) {
       case TextElement::ATOM: {
-        Vector<const uc16> data = elm.atom()->data();
-        for (int i = 0; i < data.length(); i++) {
-          os_ << static_cast<char>(data[i]);
+        ZoneGrowableArray<uint16_t>* data = elm.atom()->data();
+        for (intptr_t i = 0; i < data->length(); i++) {
+          OS::Print("%c", static_cast<char>(data->At(i)));
         }
         break;
       }
       case TextElement::CHAR_CLASS: {
         RegExpCharacterClass* node = elm.char_class();
-        os_ << "[";
-        if (node->is_negated()) os_ << "^";
-        for (int j = 0; j < node->ranges(zone)->length(); j++) {
-          CharacterRange range = node->ranges(zone)->at(j);
-          os_ << AsUC16(range.from()) << "-" << AsUC16(range.to());
+        OS::Print("[");
+        if (node->is_negated()) OS::Print("^");
+        for (intptr_t j = 0; j < node->ranges()->length(); j++) {
+          CharacterRange range = node->ranges()->At(j);
+          PrintUtf16(range.from());
+          OS::Print("-");
+          PrintUtf16(range.to());
         }
-        os_ << "]";
+        OS::Print("]");
         break;
       }
       default:
         UNREACHABLE();
     }
   }
-  os_ << "\", shape=box, peripheries=2];\n";
+  OS::Print("\", shape=box, peripheries=2];\n");
   PrintAttributes(that);
-  os_ << "  n" << that << " -> n" << that->on_success() << ";\n";
+  OS::Print("  n%p -> n%p;\n", that, that->on_success());
   Visit(that->on_success());
 }
 
 
 void DotPrinter::VisitBackReference(BackReferenceNode* that) {
-  os_ << "  n" << that << " [label=\"$" << that->start_register() << "..$"
-      << that->end_register() << "\", shape=doubleoctagon];\n";
+  OS::Print("  n%p [label=\"$%" Pd "..$%" Pd "\", shape=doubleoctagon];\n",
+            that, that->start_register(), that->end_register());
   PrintAttributes(that);
-  os_ << "  n" << that << " -> n" << that->on_success() << ";\n";
+  OS::Print("  n%p -> n%p;\n", that, that->on_success());
   Visit(that->on_success());
 }
 
 
 void DotPrinter::VisitEnd(EndNode* that) {
-  os_ << "  n" << that << " [style=bold, shape=point];\n";
+  OS::Print("  n%p [style=bold, shape=point];\n", that);
   PrintAttributes(that);
 }
 
 
 void DotPrinter::VisitAssertion(AssertionNode* that) {
-  os_ << "  n" << that << " [";
+  OS::Print("  n%p [", that);
   switch (that->assertion_type()) {
     case AssertionNode::AT_END:
-      os_ << "label=\"$\", shape=septagon";
+      OS::Print("label=\"$\", shape=septagon");
       break;
     case AssertionNode::AT_START:
-      os_ << "label=\"^\", shape=septagon";
+      OS::Print("label=\"^\", shape=septagon");
       break;
     case AssertionNode::AT_BOUNDARY:
-      os_ << "label=\"\\b\", shape=septagon";
+      OS::Print("label=\"\\b\", shape=septagon");
       break;
     case AssertionNode::AT_NON_BOUNDARY:
-      os_ << "label=\"\\B\", shape=septagon";
+      OS::Print("label=\"\\B\", shape=septagon");
       break;
     case AssertionNode::AFTER_NEWLINE:
-      os_ << "label=\"(?<=\\n)\", shape=septagon";
+      OS::Print("label=\"(?<=\\n)\", shape=septagon");
       break;
   }
-  os_ << "];\n";
+  OS::Print("];\n");
   PrintAttributes(that);
   RegExpNode* successor = that->on_success();
-  os_ << "  n" << that << " -> n" << successor << ";\n";
+  OS::Print("  n%p -> n%p;\n", that, successor);
   Visit(successor);
 }
 
 
 void DotPrinter::VisitAction(ActionNode* that) {
-  os_ << "  n" << that << " [";
+  OS::Print("  n%p [", that);
   switch (that->action_type_) {
     case ActionNode::SET_REGISTER:
-      os_ << "label=\"$" << that->data_.u_store_register.reg
-          << ":=" << that->data_.u_store_register.value << "\", shape=octagon";
+      OS::Print("label=\"$%" Pd ":=%" Pd "\", shape=octagon",
+                that->data_.u_store_register.reg,
+                that->data_.u_store_register.value);
       break;
     case ActionNode::INCREMENT_REGISTER:
-      os_ << "label=\"$" << that->data_.u_increment_register.reg
-          << "++\", shape=octagon";
+      OS::Print("label=\"$%" Pd "++\", shape=octagon",
+                that->data_.u_increment_register.reg);
       break;
     case ActionNode::STORE_POSITION:
-      os_ << "label=\"$" << that->data_.u_position_register.reg
-          << ":=$pos\", shape=octagon";
+      OS::Print("label=\"$%" Pd ":=$pos\", shape=octagon",
+                that->data_.u_position_register.reg);
       break;
     case ActionNode::BEGIN_SUBMATCH:
-      os_ << "label=\"$" << that->data_.u_submatch.current_position_register
-          << ":=$pos,begin\", shape=septagon";
+      OS::Print("label=\"$%" Pd ":=$pos,begin\", shape=septagon",
+                that->data_.u_submatch.current_position_register);
       break;
     case ActionNode::POSITIVE_SUBMATCH_SUCCESS:
-      os_ << "label=\"escape\", shape=septagon";
+      OS::Print("label=\"escape\", shape=septagon");
       break;
     case ActionNode::EMPTY_MATCH_CHECK:
-      os_ << "label=\"$" << that->data_.u_empty_match_check.start_register
-          << "=$pos?,$" << that->data_.u_empty_match_check.repetition_register
-          << "<" << that->data_.u_empty_match_check.repetition_limit
-          << "?\", shape=septagon";
+      OS::Print("label=\"$%" Pd "=$pos?,$%" Pd "<%" Pd "?\", shape=septagon",
+                that->data_.u_empty_match_check.start_register,
+                that->data_.u_empty_match_check.repetition_register,
+                that->data_.u_empty_match_check.repetition_limit);
       break;
     case ActionNode::CLEAR_CAPTURES: {
-      os_ << "label=\"clear $" << that->data_.u_clear_captures.range_from
-          << " to $" << that->data_.u_clear_captures.range_to
-          << "\", shape=septagon";
+      OS::Print("label=\"clear $%" Pd " to $%" Pd "\", shape=septagon",
+                that->data_.u_clear_captures.range_from,
+                that->data_.u_clear_captures.range_to);
       break;
     }
   }
-  os_ << "];\n";
+  OS::Print("];\n");
   PrintAttributes(that);
   RegExpNode* successor = that->on_success();
-  os_ << "  n" << that << " -> n" << successor << ";\n";
+  OS::Print("  n%p -> n%p;\n", that, successor);
   Visit(successor);
 }
 
 
-class DispatchTableDumper {
- public:
-  explicit DispatchTableDumper(OStream& os) : os_(os) {}
-  void Call(uc16 key, DispatchTable::Entry entry);
- private:
-  OStream& os_;
-};
-
-
-void DispatchTableDumper::Call(uc16 key, DispatchTable::Entry entry) {
-  os_ << "[" << AsUC16(key) << "-" << AsUC16(entry.to()) << "]: {";
-  OutSet* set = entry.out_set();
-  bool first = true;
-  for (unsigned i = 0; i < OutSet::kFirstLimit; i++) {
-    if (set->Get(i)) {
-      if (first) {
-        first = false;
-      } else {
-        os_ << ", ";
-      }
-      os_ << i;
-    }
-  }
-  os_ << "}\n";
-}
-
-
-void DispatchTable::Dump() {
-  OFStream os(stderr);
-  DispatchTableDumper dumper(os);
-  tree()->ForEach(&dumper);
-}
-
-
 void RegExpEngine::DotPrint(const char* label,
                             RegExpNode* node,
                             bool ignore_case) {
-  OFStream os(stdout);
-  DotPrinter printer(os, ignore_case);
+  DotPrinter printer(ignore_case);
   printer.PrintNode(label, node);
 }
 
@@ -4001,39 +3952,44 @@ void RegExpEngine::DotPrint(const char* label,
 
 RegExpNode* RegExpAtom::ToNode(RegExpCompiler* compiler,
                                RegExpNode* on_success) {
-  ZoneList<TextElement>* elms =
-      new(compiler->zone()) ZoneList<TextElement>(1, compiler->zone());
-  elms->Add(TextElement::Atom(this), compiler->zone());
-  return new(compiler->zone()) TextNode(elms, on_success);
+  ZoneGrowableArray<TextElement>* elms =
+      new(CI) ZoneGrowableArray<TextElement>(1);
+  elms->Add(TextElement::Atom(this));
+  return new(CI) TextNode(elms, on_success);
 }
 
 
 RegExpNode* RegExpText::ToNode(RegExpCompiler* compiler,
                                RegExpNode* on_success) {
-  return new(compiler->zone()) TextNode(elements(), on_success);
+  ZoneGrowableArray<TextElement>* elms =
+      new(CI) ZoneGrowableArray<TextElement>(1);
+  for (intptr_t  i = 0; i < elements()->length(); i++) {
+    elms->Add(elements()->At(i));
+  }
+  return new(CI) TextNode(elms, on_success);
 }
 
 
-static bool CompareInverseRanges(ZoneList<CharacterRange>* ranges,
-                                 const int* special_class,
-                                 int length) {
+static bool CompareInverseRanges(ZoneGrowableArray<CharacterRange>* ranges,
+                                 const intptr_t* special_class,
+                                 intptr_t length) {
   length--;  // Remove final 0x10000.
-  DCHECK(special_class[length] == 0x10000);
-  DCHECK(ranges->length() != 0);
-  DCHECK(length != 0);
-  DCHECK(special_class[0] != 0);
+  ASSERT(special_class[length] == 0x10000);
+  ASSERT(ranges->length() != 0);
+  ASSERT(length != 0);
+  ASSERT(special_class[0] != 0);
   if (ranges->length() != (length >> 1) + 1) {
     return false;
   }
-  CharacterRange range = ranges->at(0);
+  CharacterRange range = ranges->At(0);
   if (range.from() != 0) {
     return false;
   }
-  for (int i = 0; i < length; i += 2) {
+  for (intptr_t i = 0; i < length; i += 2) {
     if (special_class[i] != (range.to() + 1)) {
       return false;
     }
-    range = ranges->at((i >> 1) + 1);
+    range = ranges->At((i >> 1) + 1);
     if (special_class[i+1] != range.from()) {
       return false;
     }
@@ -4045,16 +4001,16 @@ static bool CompareInverseRanges(ZoneList<CharacterRange>* ranges,
 }
 
 
-static bool CompareRanges(ZoneList<CharacterRange>* ranges,
-                          const int* special_class,
-                          int length) {
+static bool CompareRanges(ZoneGrowableArray<CharacterRange>* ranges,
+                          const intptr_t* special_class,
+                          intptr_t length) {
   length--;  // Remove final 0x10000.
-  DCHECK(special_class[length] == 0x10000);
+  ASSERT(special_class[length] == 0x10000);
   if (ranges->length() * 2 != length) {
     return false;
   }
-  for (int i = 0; i < length; i += 2) {
-    CharacterRange range = ranges->at(i >> 1);
+  for (intptr_t i = 0; i < length; i += 2) {
+    CharacterRange range = ranges->At(i >> 1);
     if (range.from() != special_class[i] ||
         range.to() != special_class[i + 1] - 1) {
       return false;
@@ -4064,7 +4020,7 @@ static bool CompareRanges(ZoneList<CharacterRange>* ranges,
 }
 
 
-bool RegExpCharacterClass::is_standard(Zone* zone) {
+bool RegExpCharacterClass::is_standard() {
   // TODO(lrn): Remove need for this function, by not throwing away information
   // along the way.
   if (is_negated_) {
@@ -4073,31 +4029,31 @@ bool RegExpCharacterClass::is_standard(Zone* zone) {
   if (set_.is_standard()) {
     return true;
   }
-  if (CompareRanges(set_.ranges(zone), kSpaceRanges, kSpaceRangeCount)) {
+  if (CompareRanges(set_.ranges(), kSpaceRanges, kSpaceRangeCount)) {
     set_.set_standard_set_type('s');
     return true;
   }
-  if (CompareInverseRanges(set_.ranges(zone), kSpaceRanges, kSpaceRangeCount)) {
+  if (CompareInverseRanges(set_.ranges(), kSpaceRanges, kSpaceRangeCount)) {
     set_.set_standard_set_type('S');
     return true;
   }
-  if (CompareInverseRanges(set_.ranges(zone),
+  if (CompareInverseRanges(set_.ranges(),
                            kLineTerminatorRanges,
                            kLineTerminatorRangeCount)) {
     set_.set_standard_set_type('.');
     return true;
   }
-  if (CompareRanges(set_.ranges(zone),
+  if (CompareRanges(set_.ranges(),
                     kLineTerminatorRanges,
                     kLineTerminatorRangeCount)) {
     set_.set_standard_set_type('n');
     return true;
   }
-  if (CompareRanges(set_.ranges(zone), kWordRanges, kWordRangeCount)) {
+  if (CompareRanges(set_.ranges(), kWordRanges, kWordRangeCount)) {
     set_.set_standard_set_type('w');
     return true;
   }
-  if (CompareInverseRanges(set_.ranges(zone), kWordRanges, kWordRangeCount)) {
+  if (CompareInverseRanges(set_.ranges(), kWordRanges, kWordRangeCount)) {
     set_.set_standard_set_type('W');
     return true;
   }
@@ -4107,18 +4063,18 @@ bool RegExpCharacterClass::is_standard(Zone* zone) {
 
 RegExpNode* RegExpCharacterClass::ToNode(RegExpCompiler* compiler,
                                          RegExpNode* on_success) {
-  return new(compiler->zone()) TextNode(this, on_success);
+  return new(CI) TextNode(this, on_success);
 }
 
 
 RegExpNode* RegExpDisjunction::ToNode(RegExpCompiler* compiler,
                                       RegExpNode* on_success) {
-  ZoneList<RegExpTree*>* alternatives = this->alternatives();
-  int length = alternatives->length();
+  ZoneGrowableArray<RegExpTree*>* alternatives = this->alternatives();
+  intptr_t length = alternatives->length();
   ChoiceNode* result =
-      new(compiler->zone()) ChoiceNode(length, compiler->zone());
-  for (int i = 0; i < length; i++) {
-    GuardedAlternative alternative(alternatives->at(i)->ToNode(compiler,
+      new(CI) ChoiceNode(length, CI);
+  for (intptr_t i = 0; i < length; i++) {
+    GuardedAlternative alternative(alternatives->At(i)->ToNode(compiler,
                                                                on_success));
     result->AddAlternative(alternative);
   }
@@ -4139,21 +4095,21 @@ RegExpNode* RegExpQuantifier::ToNode(RegExpCompiler* compiler,
 
 // Scoped object to keep track of how much we unroll quantifier loops in the
 // regexp graph generator.
-class RegExpExpansionLimiter {
+class RegExpExpansionLimiter : public ValueObject {
  public:
-  static const int kMaxExpansionFactor = 6;
-  RegExpExpansionLimiter(RegExpCompiler* compiler, int factor)
+  static const intptr_t kMaxExpansionFactor = 6;
+  RegExpExpansionLimiter(RegExpCompiler* compiler, intptr_t factor)
       : compiler_(compiler),
         saved_expansion_factor_(compiler->current_expansion_factor()),
         ok_to_expand_(saved_expansion_factor_ <= kMaxExpansionFactor) {
-    DCHECK(factor > 0);
+    ASSERT(factor > 0);
     if (ok_to_expand_) {
       if (factor > kMaxExpansionFactor) {
         // Avoid integer overflow of the current expansion factor.
         ok_to_expand_ = false;
         compiler->set_current_expansion_factor(kMaxExpansionFactor + 1);
       } else {
-        int new_factor = saved_expansion_factor_ * factor;
+        intptr_t new_factor = saved_expansion_factor_ * factor;
         ok_to_expand_ = (new_factor <= kMaxExpansionFactor);
         compiler->set_current_expansion_factor(new_factor);
       }
@@ -4168,15 +4124,15 @@ class RegExpExpansionLimiter {
 
  private:
   RegExpCompiler* compiler_;
-  int saved_expansion_factor_;
+  intptr_t saved_expansion_factor_;
   bool ok_to_expand_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(RegExpExpansionLimiter);
 };
 
 
-RegExpNode* RegExpQuantifier::ToNode(int min,
-                                     int max,
+RegExpNode* RegExpQuantifier::ToNode(intptr_t min,
+                                     intptr_t max,
                                      bool is_greedy,
                                      RegExpTree* body,
                                      RegExpCompiler* compiler,
@@ -4202,25 +4158,27 @@ RegExpNode* RegExpQuantifier::ToNode(int min,
   // simpler since we don't need to make the special zero length match check
   // from step 2.1.  If the min and max are small we can unroll a little in
   // this case.
-  static const int kMaxUnrolledMinMatches = 3;  // Unroll (foo)+ and (foo){3,}
-  static const int kMaxUnrolledMaxMatches = 3;  // Unroll (foo)? and (foo){x,3}
+  // 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);
-  int body_start_reg = RegExpCompiler::kNoRegister;
+  intptr_t body_start_reg = RegExpCompiler::kNoRegister;
   Interval capture_registers = body->CaptureRegisters();
   bool needs_capture_clearing = !capture_registers.is_empty();
-  Zone* zone = compiler->zone();
+  Isolate* isolate = compiler->isolate();
 
   if (body_can_be_empty) {
     body_start_reg = compiler->AllocateRegister();
-  } else if (FLAG_regexp_optimization && !needs_capture_clearing) {
+  } 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()) {
-        int new_max = (max == kInfinity) ? max : max - min;
+        intptr_t new_max = (max == kInfinity) ? max : max - min;
         // Recurse once to get the loop or optional matches after the fixed
         // ones.
         RegExpNode* answer = ToNode(
@@ -4228,20 +4186,20 @@ RegExpNode* RegExpQuantifier::ToNode(int min,
         // Unroll the forced matches from 0 to min.  This can cause chains of
         // TextNodes (which the parser does not generate).  These should be
         // combined if it turns out they hinder good code generation.
-        for (int i = 0; i < min; i++) {
+        for (intptr_t i = 0; i < min; i++) {
           answer = body->ToNode(compiler, answer);
         }
         return answer;
       }
     }
     if (max <= kMaxUnrolledMaxMatches && min == 0) {
-      DCHECK(max > 0);  // Due to the 'if' above.
+      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(zone) ChoiceNode(2, zone);
+        for (intptr_t i = 0; i < max; i++) {
+          ChoiceNode* alternation = new(isolate) ChoiceNode(2, isolate);
           if (is_greedy) {
             alternation->AddAlternative(
                 GuardedAlternative(body->ToNode(compiler, answer)));
@@ -4261,11 +4219,11 @@ RegExpNode* RegExpQuantifier::ToNode(int min,
   bool has_min = min > 0;
   bool has_max = max < RegExpTree::kInfinity;
   bool needs_counter = has_min || has_max;
-  int reg_ctr = needs_counter
+  intptr_t reg_ctr = needs_counter
       ? compiler->AllocateRegister()
       : RegExpCompiler::kNoRegister;
-  LoopChoiceNode* center = new(zone) LoopChoiceNode(body->min_match() == 0,
-                                                    zone);
+  LoopChoiceNode* center = new(isolate) LoopChoiceNode(body->min_match() == 0,
+                                                       isolate);
   if (not_at_start) center->set_not_at_start();
   RegExpNode* loop_return = needs_counter
       ? static_cast<RegExpNode*>(ActionNode::IncrementRegister(reg_ctr, center))
@@ -4291,13 +4249,13 @@ RegExpNode* RegExpQuantifier::ToNode(int min,
   GuardedAlternative body_alt(body_node);
   if (has_max) {
     Guard* body_guard =
-        new(zone) Guard(reg_ctr, Guard::LT, max);
-    body_alt.AddGuard(body_guard, zone);
+        new(isolate) Guard(reg_ctr, Guard::LT, max);
+    body_alt.AddGuard(body_guard, isolate);
   }
   GuardedAlternative rest_alt(on_success);
   if (has_min) {
-    Guard* rest_guard = new(compiler->zone()) Guard(reg_ctr, Guard::GEQ, min);
-    rest_alt.AddGuard(rest_guard, zone);
+    Guard* rest_guard = new(isolate) Guard(reg_ctr, Guard::GEQ, min);
+    rest_alt.AddGuard(rest_guard, isolate);
   }
   if (is_greedy) {
     center->AddLoopAlternative(body_alt);
@@ -4316,9 +4274,6 @@ RegExpNode* RegExpQuantifier::ToNode(int min,
 
 RegExpNode* RegExpAssertion::ToNode(RegExpCompiler* compiler,
                                     RegExpNode* on_success) {
-  NodeInfo info;
-  Zone* zone = compiler->zone();
-
   switch (assertion_type()) {
     case START_OF_LINE:
       return AssertionNode::AfterNewline(on_success);
@@ -4334,16 +4289,16 @@ RegExpNode* RegExpAssertion::ToNode(RegExpCompiler* compiler,
       // 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();
+      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(zone) ChoiceNode(2, zone);
+      ChoiceNode* result = new ChoiceNode(2, on_success->isolate());
       // Create a newline atom.
-      ZoneList<CharacterRange>* newline_ranges =
-          new(zone) ZoneList<CharacterRange>(3, zone);
-      CharacterRange::AddClassEscape('n', newline_ranges, zone);
-      RegExpCharacterClass* newline_atom = new(zone) RegExpCharacterClass('n');
-      TextNode* newline_matcher = new(zone) TextNode(
+      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,
@@ -4371,7 +4326,7 @@ RegExpNode* RegExpAssertion::ToNode(RegExpCompiler* compiler,
 
 RegExpNode* RegExpBackReference::ToNode(RegExpCompiler* compiler,
                                         RegExpNode* on_success) {
-  return new(compiler->zone())
+  return new(CI)
       BackReferenceNode(RegExpCapture::StartRegister(index()),
                         RegExpCapture::EndRegister(index()),
                         on_success);
@@ -4386,13 +4341,13 @@ RegExpNode* RegExpEmpty::ToNode(RegExpCompiler* compiler,
 
 RegExpNode* RegExpLookahead::ToNode(RegExpCompiler* compiler,
                                     RegExpNode* on_success) {
-  int stack_pointer_register = compiler->AllocateRegister();
-  int position_register = compiler->AllocateRegister();
+  intptr_t stack_pointer_register = compiler->AllocateRegister();
+  intptr_t position_register = compiler->AllocateRegister();
 
-  const int registers_per_capture = 2;
-  const int register_of_first_capture = 2;
-  int register_count = capture_count_ * registers_per_capture;
-  int register_start =
+  const intptr_t registers_per_capture = 2;
+  const intptr_t register_of_first_capture = 2;
+  intptr_t register_count = capture_count_ * registers_per_capture;
+  intptr_t register_start =
     register_of_first_capture + capture_from_ * registers_per_capture;
 
   RegExpNode* success;
@@ -4419,20 +4374,19 @@ RegExpNode* RegExpLookahead::ToNode(RegExpCompiler* compiler,
     // for a negative lookahead.  The NegativeLookaheadChoiceNode is a special
     // ChoiceNode that knows to ignore the first exit when calculating quick
     // checks.
-    Zone* zone = compiler->zone();
 
     GuardedAlternative body_alt(
         body()->ToNode(
             compiler,
-            success = new(zone) NegativeSubmatchSuccess(stack_pointer_register,
-                                                        position_register,
-                                                        register_count,
-                                                        register_start,
-                                                        zone)));
+            success = new(CI) NegativeSubmatchSuccess(stack_pointer_register,
+                                                      position_register,
+                                                      register_count,
+                                                      register_start,
+                                                      CI)));
     ChoiceNode* choice_node =
-        new(zone) NegativeLookaheadChoiceNode(body_alt,
-                                              GuardedAlternative(on_success),
-                                              zone);
+        new(CI) NegativeLookaheadChoiceNode(body_alt,
+                                            GuardedAlternative(on_success),
+                                            CI);
     return ActionNode::BeginSubmatch(stack_pointer_register,
                                      position_register,
                                      choice_node);
@@ -4447,11 +4401,11 @@ RegExpNode* RegExpCapture::ToNode(RegExpCompiler* compiler,
 
 
 RegExpNode* RegExpCapture::ToNode(RegExpTree* body,
-                                  int index,
+                                  intptr_t index,
                                   RegExpCompiler* compiler,
                                   RegExpNode* on_success) {
-  int start_reg = RegExpCapture::StartRegister(index);
-  int end_reg = RegExpCapture::EndRegister(index);
+  intptr_t start_reg = RegExpCapture::StartRegister(index);
+  intptr_t end_reg = RegExpCapture::EndRegister(index);
   RegExpNode* store_end = ActionNode::StorePosition(end_reg, true, on_success);
   RegExpNode* body_node = body->ToNode(compiler, store_end);
   return ActionNode::StorePosition(start_reg, true, body_node);
@@ -4460,88 +4414,83 @@ RegExpNode* RegExpCapture::ToNode(RegExpTree* body,
 
 RegExpNode* RegExpAlternative::ToNode(RegExpCompiler* compiler,
                                       RegExpNode* on_success) {
-  ZoneList<RegExpTree*>* children = nodes();
+  ZoneGrowableArray<RegExpTree*>* children = nodes();
   RegExpNode* current = on_success;
-  for (int i = children->length() - 1; i >= 0; i--) {
-    current = children->at(i)->ToNode(compiler, current);
+  for (intptr_t i = children->length() - 1; i >= 0; i--) {
+    current = children->At(i)->ToNode(compiler, current);
   }
   return current;
 }
 
 
-static void AddClass(const int* elmv,
-                     int elmc,
-                     ZoneList<CharacterRange>* ranges,
-                     Zone* zone) {
+static void AddClass(const intptr_t* elmv,
+                     intptr_t elmc,
+                     ZoneGrowableArray<CharacterRange>* ranges) {
   elmc--;
-  DCHECK(elmv[elmc] == 0x10000);
-  for (int i = 0; i < elmc; i += 2) {
-    DCHECK(elmv[i] < elmv[i + 1]);
-    ranges->Add(CharacterRange(elmv[i], elmv[i + 1] - 1), zone);
+  ASSERT(elmv[elmc] == 0x10000);
+  for (intptr_t i = 0; i < elmc; i += 2) {
+    ASSERT(elmv[i] < elmv[i + 1]);
+    ranges->Add(CharacterRange(elmv[i], elmv[i + 1] - 1));
   }
 }
 
 
-static void AddClassNegated(const int *elmv,
-                            int elmc,
-                            ZoneList<CharacterRange>* ranges,
-                            Zone* zone) {
+static void AddClassNegated(const intptr_t *elmv,
+                            intptr_t elmc,
+                            ZoneGrowableArray<CharacterRange>* ranges) {
   elmc--;
-  DCHECK(elmv[elmc] == 0x10000);
-  DCHECK(elmv[0] != 0x0000);
-  DCHECK(elmv[elmc-1] != String::kMaxUtf16CodeUnit);
-  uc16 last = 0x0000;
-  for (int i = 0; i < elmc; i += 2) {
-    DCHECK(last <= elmv[i] - 1);
-    DCHECK(elmv[i] < elmv[i + 1]);
-    ranges->Add(CharacterRange(last, elmv[i] - 1), zone);
+  ASSERT(elmv[elmc] == 0x10000);
+  ASSERT(elmv[0] != 0x0000);
+  ASSERT(elmv[elmc-1] != Utf16::kMaxCodeUnit);
+  uint16_t last = 0x0000;
+  for (intptr_t i = 0; i < elmc; i += 2) {
+    ASSERT(last <= elmv[i] - 1);
+    ASSERT(elmv[i] < elmv[i + 1]);
+    ranges->Add(CharacterRange(last, elmv[i] - 1));
     last = elmv[i + 1];
   }
-  ranges->Add(CharacterRange(last, String::kMaxUtf16CodeUnit), zone);
+  ranges->Add(CharacterRange(last, Utf16::kMaxCodeUnit));
 }
 
 
-void CharacterRange::AddClassEscape(uc16 type,
-                                    ZoneList<CharacterRange>* ranges,
-                                    Zone* zone) {
+void CharacterRange::AddClassEscape(uint16_t type,
+                                    ZoneGrowableArray<CharacterRange>* ranges) {
   switch (type) {
     case 's':
-      AddClass(kSpaceRanges, kSpaceRangeCount, ranges, zone);
+      AddClass(kSpaceRanges, kSpaceRangeCount, ranges);
       break;
     case 'S':
-      AddClassNegated(kSpaceRanges, kSpaceRangeCount, ranges, zone);
+      AddClassNegated(kSpaceRanges, kSpaceRangeCount, ranges);
       break;
     case 'w':
-      AddClass(kWordRanges, kWordRangeCount, ranges, zone);
+      AddClass(kWordRanges, kWordRangeCount, ranges);
       break;
     case 'W':
-      AddClassNegated(kWordRanges, kWordRangeCount, ranges, zone);
+      AddClassNegated(kWordRanges, kWordRangeCount, ranges);
       break;
     case 'd':
-      AddClass(kDigitRanges, kDigitRangeCount, ranges, zone);
+      AddClass(kDigitRanges, kDigitRangeCount, ranges);
       break;
     case 'D':
-      AddClassNegated(kDigitRanges, kDigitRangeCount, ranges, zone);
+      AddClassNegated(kDigitRanges, kDigitRangeCount, ranges);
       break;
     case '.':
       AddClassNegated(kLineTerminatorRanges,
                       kLineTerminatorRangeCount,
-                      ranges,
-                      zone);
+                      ranges);
       break;
     // This is not a character range as defined by the spec but a
     // convenient shorthand for a character class that matches any
     // character.
     case '*':
-      ranges->Add(CharacterRange::Everything(), zone);
+      ranges->Add(CharacterRange::Everything());
       break;
     // This is the set of characters matched by the $ and ^ symbols
     // in multiline mode.
     case 'n':
       AddClass(kLineTerminatorRanges,
                kLineTerminatorRangeCount,
-               ranges,
-               zone);
+               ranges);
       break;
     default:
       UNREACHABLE();
@@ -4549,77 +4498,29 @@ void CharacterRange::AddClassEscape(uc16 type,
 }
 
 
-Vector<const int> CharacterRange::GetWordBounds() {
-  return Vector<const int>(kWordRanges, kWordRangeCount - 1);
-}
-
-
-class CharacterRangeSplitter {
- public:
-  CharacterRangeSplitter(ZoneList<CharacterRange>** included,
-                         ZoneList<CharacterRange>** excluded,
-                         Zone* zone)
-      : included_(included),
-        excluded_(excluded),
-        zone_(zone) { }
-  void Call(uc16 from, DispatchTable::Entry entry);
-
-  static const int kInBase = 0;
-  static const int kInOverlay = 1;
-
- private:
-  ZoneList<CharacterRange>** included_;
-  ZoneList<CharacterRange>** excluded_;
-  Zone* zone_;
-};
-
-
-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(zone_) ZoneList<CharacterRange>(2, zone_);
-  (*target)->Add(CharacterRange(entry.from(), entry.to()), zone_);
-}
-
-
-void CharacterRange::Split(ZoneList<CharacterRange>* base,
-                           Vector<const int> overlay,
-                           ZoneList<CharacterRange>** included,
-                           ZoneList<CharacterRange>** excluded,
-                           Zone* zone) {
-  DCHECK_EQ(NULL, *included);
-  DCHECK_EQ(NULL, *excluded);
-  DispatchTable table(zone);
-  for (int i = 0; i < base->length(); i++)
-    table.AddRange(base->at(i), CharacterRangeSplitter::kInBase, zone);
-  for (int i = 0; i < overlay.length(); i += 2) {
-    table.AddRange(CharacterRange(overlay[i], overlay[i + 1] - 1),
-                   CharacterRangeSplitter::kInOverlay, zone);
-  }
-  CharacterRangeSplitter callback(included, excluded, zone);
-  table.ForEach(&callback);
-}
-
-
-void CharacterRange::AddCaseEquivalents(ZoneList<CharacterRange>* ranges,
-                                        bool is_one_byte, Zone* zone) {
-  Isolate* isolate = zone->isolate();
-  uc16 bottom = from();
-  uc16 top = to();
+void CharacterRange::AddCaseEquivalents(
+                        ZoneGrowableArray<CharacterRange>* ranges,
+                        bool is_one_byte,
+                        Isolate* isolate) {
+  uint16_t bottom = from();
+  uint16_t top = to();
   if (is_one_byte && !RangeContainsLatin1Equivalents(*this)) {
-    if (bottom > String::kMaxOneByteCharCode) return;
-    if (top > String::kMaxOneByteCharCode) top = String::kMaxOneByteCharCode;
+    if (bottom > Symbols::kMaxOneCharCodeSymbol) return;
+    if (top > Symbols::kMaxOneCharCodeSymbol) {
+      top = Symbols::kMaxOneCharCodeSymbol;
+    }
   }
-  unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
+
+  unibrow::Mapping<unibrow::Ecma262UnCanonicalize> jsregexp_uncanonicalize;
+  unibrow::Mapping<unibrow::CanonicalizationRange> jsregexp_canonrange;
+  int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
   if (top == bottom) {
     // If this is a singleton we just expand the one character.
-    int length = isolate->jsregexp_uncanonicalize()->get(bottom, '\0', chars);
-    for (int i = 0; i < length; i++) {
-      uc32 chr = chars[i];
+    intptr_t length = jsregexp_uncanonicalize.get(bottom, '\0', chars); // NOLINT
+    for (intptr_t i = 0; i < length; i++) {
+      uint32_t chr = chars[i];
       if (chr != bottom) {
-        ranges->Add(CharacterRange::Singleton(chars[i]), zone);
+        ranges->Add(CharacterRange::Singleton(chars[i]));
       }
     }
   } else {
@@ -4641,25 +4542,25 @@ void CharacterRange::AddCaseEquivalents(ZoneList<CharacterRange>* ranges,
     // completely contained in a block we do this for all the blocks
     // covered by the range (handling characters that is not in a block
     // as a "singleton block").
-    unibrow::uchar range[unibrow::Ecma262UnCanonicalize::kMaxWidth];
-    int pos = bottom;
+    int32_t range[unibrow::Ecma262UnCanonicalize::kMaxWidth];
+    intptr_t pos = bottom;
     while (pos <= top) {
-      int length = isolate->jsregexp_canonrange()->get(pos, '\0', range);
-      uc16 block_end;
+      intptr_t length = jsregexp_canonrange.get(pos, '\0', range);
+      uint16_t block_end;
       if (length == 0) {
         block_end = pos;
       } else {
-        DCHECK_EQ(1, length);
+        ASSERT(length == 1);
         block_end = range[0];
       }
-      int end = (block_end > top) ? top : block_end;
-      length = isolate->jsregexp_uncanonicalize()->get(block_end, '\0', range);
-      for (int i = 0; i < length; i++) {
-        uc32 c = range[i];
-        uc16 range_from = c - (block_end - pos);
-        uc16 range_to = c - (block_end - end);
+      intptr_t end = (block_end > top) ? top : block_end;
+      length = jsregexp_uncanonicalize.get(block_end, '\0', range); // NOLINT
+      for (intptr_t i = 0; i < length; i++) {
+        uint32_t c = range[i];
+        uint16_t range_from = c - (block_end - pos);
+        uint16_t range_to = c - (block_end - end);
         if (!(bottom <= range_from && range_to <= top)) {
-          ranges->Add(CharacterRange(range_from, range_to), zone);
+          ranges->Add(CharacterRange(range_from, range_to));
         }
       }
       pos = end + 1;
@@ -4668,13 +4569,13 @@ void CharacterRange::AddCaseEquivalents(ZoneList<CharacterRange>* ranges,
 }
 
 
-bool CharacterRange::IsCanonical(ZoneList<CharacterRange>* ranges) {
-  DCHECK_NOT_NULL(ranges);
-  int n = ranges->length();
+bool CharacterRange::IsCanonical(ZoneGrowableArray<CharacterRange>* ranges) {
+  ASSERT(ranges != NULL);
+  intptr_t n = ranges->length();
   if (n <= 1) return true;
-  int max = ranges->at(0).to();
-  for (int i = 1; i < n; i++) {
-    CharacterRange next_range = ranges->at(i);
+  intptr_t max = ranges->At(0).to();
+  for (intptr_t i = 1; i < n; i++) {
+    CharacterRange next_range = ranges->At(i);
     if (next_range.from() <= max + 1) return false;
     max = next_range.to();
   }
@@ -4682,48 +4583,49 @@ bool CharacterRange::IsCanonical(ZoneList<CharacterRange>* ranges) {
 }
 
 
-ZoneList<CharacterRange>* CharacterSet::ranges(Zone* zone) {
+ZoneGrowableArray<CharacterRange>* CharacterSet::ranges() {
   if (ranges_ == NULL) {
-    ranges_ = new(zone) ZoneList<CharacterRange>(2, zone);
-    CharacterRange::AddClassEscape(standard_set_type_, ranges_, zone);
+    ranges_ = new ZoneGrowableArray<CharacterRange>(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,
-                       int to,
-                       int count) {
+// Move a number of elements in a zone array to another position
+// in the same array. Handles overlapping source and target areas.
+static void MoveRanges(ZoneGrowableArray<CharacterRange>* list,
+                       intptr_t from,
+                       intptr_t to,
+                       intptr_t count) {
   // Ranges are potentially overlapping.
   if (from < to) {
-    for (int i = count - 1; i >= 0; i--) {
-      list->at(to + i) = list->at(from + i);
+    for (intptr_t i = count - 1; i >= 0; i--) {
+      (*list)[to + i] = list->At(from + i);
     }
   } else {
-    for (int i = 0; i < count; i++) {
-      list->at(to + i) = list->at(from + i);
+    for (intptr_t i = 0; i < count; i++) {
+      (*list)[to + i] = list->At(from + i);
     }
   }
 }
 
 
-static int InsertRangeInCanonicalList(ZoneList<CharacterRange>* list,
-                                      int count,
-                                      CharacterRange insert) {
+static intptr_t InsertRangeInCanonicalList(
+                    ZoneGrowableArray<CharacterRange>* list,
+                    intptr_t count,
+                    CharacterRange insert) {
   // Inserts a range into list[0..count[, which must be sorted
   // by from value and non-overlapping and non-adjacent, using at most
   // list[0..count] for the result. Returns the number of resulting
   // canonicalized ranges. Inserting a range may collapse existing ranges into
   // fewer ranges, so the return value can be anything in the range 1..count+1.
-  uc16 from = insert.from();
-  uc16 to = insert.to();
-  int start_pos = 0;
-  int end_pos = count;
-  for (int i = count - 1; i >= 0; i--) {
-    CharacterRange current = list->at(i);
+  uint16_t from = insert.from();
+  uint16_t to = insert.to();
+  intptr_t start_pos = 0;
+  intptr_t end_pos = count;
+  for (intptr_t i = count - 1; i >= 0; i--) {
+    CharacterRange current = list->At(i);
     if (current.from() > to + 1) {
       end_pos = i;
     } else if (current.to() + 1 < from) {
@@ -4744,26 +4646,26 @@ static int InsertRangeInCanonicalList(ZoneList<CharacterRange>* list,
     if (start_pos < count) {
       MoveRanges(list, start_pos, start_pos + 1, count - start_pos);
     }
-    list->at(start_pos) = insert;
+    (*list)[start_pos] = insert;
     return count + 1;
   }
   if (start_pos + 1 == end_pos) {
     // Replace single existing range at position start_pos.
-    CharacterRange to_replace = list->at(start_pos);
-    int new_from = Min(to_replace.from(), from);
-    int new_to = Max(to_replace.to(), to);
-    list->at(start_pos) = CharacterRange(new_from, new_to);
+    CharacterRange to_replace = list->At(start_pos);
+    intptr_t new_from = Utils::Minimum(to_replace.from(), from);
+    intptr_t new_to = Utils::Maximum(to_replace.to(), to);
+    (*list)[start_pos] = CharacterRange(new_from, new_to);
     return count;
   }
   // Replace a number of existing ranges from start_pos to end_pos - 1.
   // Move the remaining ranges down.
 
-  int new_from = Min(list->at(start_pos).from(), from);
-  int new_to = Max(list->at(end_pos - 1).to(), to);
+  intptr_t new_from = Utils::Minimum(list->At(start_pos).from(), from);
+  intptr_t new_to = Utils::Maximum(list->At(end_pos - 1).to(), to);
   if (end_pos < count) {
     MoveRanges(list, end_pos, start_pos + 1, count - end_pos);
   }
-  list->at(start_pos) = CharacterRange(new_from, new_to);
+  (*list)[start_pos] = CharacterRange(new_from, new_to);
   return count - (end_pos - start_pos) + 1;
 }
 
@@ -4776,15 +4678,16 @@ void CharacterSet::Canonicalize() {
 }
 
 
-void CharacterRange::Canonicalize(ZoneList<CharacterRange>* character_ranges) {
+void CharacterRange::Canonicalize(
+    ZoneGrowableArray<CharacterRange>* character_ranges) {
   if (character_ranges->length() <= 1) return;
   // Check whether ranges are already canonical (increasing, non-overlapping,
   // non-adjacent).
-  int n = character_ranges->length();
-  int max = character_ranges->at(0).to();
-  int i = 1;
+  intptr_t n = character_ranges->length();
+  intptr_t max = character_ranges->At(0).to();
+  intptr_t i = 1;
   while (i < n) {
-    CharacterRange current = character_ranges->at(i);
+    CharacterRange current = character_ranges->At(i);
     if (current.from() <= max + 1) {
       break;
     }
@@ -4799,41 +4702,39 @@ void CharacterRange::Canonicalize(ZoneList<CharacterRange>* character_ranges) {
   // list, in order).
   // Notice that inserting a range can reduce the number of ranges in the
   // result due to combining of adjacent and overlapping ranges.
-  int read = i;  // Range to insert.
-  int num_canonical = i;  // Length of canonicalized part of list.
+  intptr_t read = i;  // Range to insert.
+  intptr_t num_canonical = i;  // Length of canonicalized part of list.
   do {
     num_canonical = InsertRangeInCanonicalList(character_ranges,
                                                num_canonical,
-                                               character_ranges->at(read));
+                                               character_ranges->At(read));
     read++;
   } while (read < n);
-  character_ranges->Rewind(num_canonical);
+  character_ranges->TruncateTo(num_canonical);
 
-  DCHECK(CharacterRange::IsCanonical(character_ranges));
+  ASSERT(CharacterRange::IsCanonical(character_ranges));
 }
 
 
-void CharacterRange::Negate(ZoneList<CharacterRange>* ranges,
-                            ZoneList<CharacterRange>* negated_ranges,
-                            Zone* zone) {
-  DCHECK(CharacterRange::IsCanonical(ranges));
-  DCHECK_EQ(0, negated_ranges->length());
-  int range_count = ranges->length();
-  uc16 from = 0;
-  int i = 0;
-  if (range_count > 0 && ranges->at(0).from() == 0) {
-    from = ranges->at(0).to();
+void CharacterRange::Negate(ZoneGrowableArray<CharacterRange>* ranges,
+                            ZoneGrowableArray<CharacterRange>* negated_ranges) {
+  ASSERT(CharacterRange::IsCanonical(ranges));
+  ASSERT(negated_ranges->length() == 0);
+  intptr_t range_count = ranges->length();
+  uint16_t from = 0;
+  intptr_t i = 0;
+  if (range_count > 0 && ranges->At(0).from() == 0) {
+    from = ranges->At(0).to();
     i = 1;
   }
   while (i < range_count) {
-    CharacterRange range = ranges->at(i);
-    negated_ranges->Add(CharacterRange(from + 1, range.from() - 1), zone);
+    CharacterRange range = ranges->At(i);
+    negated_ranges->Add(CharacterRange(from + 1, range.from() - 1));
     from = range.to();
     i++;
   }
-  if (from < String::kMaxUtf16CodeUnit) {
-    negated_ranges->Add(CharacterRange(from + 1, String::kMaxUtf16CodeUnit),
-                        zone);
+  if (from < Utf16::kMaxCodeUnit) {
+    negated_ranges->Add(CharacterRange(from + 1, Utf16::kMaxCodeUnit));
   }
 }
 
@@ -4842,33 +4743,29 @@ void CharacterRange::Negate(ZoneList<CharacterRange>* ranges,
 // Splay tree
 
 
-OutSet* OutSet::Extend(unsigned value, Zone* zone) {
-  if (Get(value))
-    return this;
-  if (successors(zone) != NULL) {
-    for (int i = 0; i < successors(zone)->length(); i++) {
-      OutSet* successor = successors(zone)->at(i);
-      if (successor->Get(value))
-        return successor;
+// Workaround for the fact that ZoneGrowableArray does not have contains().
+static bool ArrayContains(ZoneGrowableArray<unsigned>* array,
+                          unsigned value) {
+  for (intptr_t i = 0; i < array->length(); i++) {
+    if (array->At(i) == value) {
+      return true;
     }
-  } else {
-    successors_ = new(zone) ZoneList<OutSet*>(2, zone);
   }
-  OutSet* result = new(zone) OutSet(first_, remaining_);
-  result->Set(value, zone);
-  successors(zone)->Add(result, zone);
-  return result;
+  return false;
 }
 
 
-void OutSet::Set(unsigned value, Zone *zone) {
+void OutSet::Set(unsigned value, Isolate* isolate) {
   if (value < kFirstLimit) {
     first_ |= (1 << value);
   } else {
     if (remaining_ == NULL)
-      remaining_ = new(zone) ZoneList<unsigned>(1, zone);
-    if (remaining_->is_empty() || !remaining_->Contains(value))
-      remaining_->Add(value, zone);
+      remaining_ = new(isolate) ZoneGrowableArray<unsigned>(1);
+
+    bool remaining_contains_value = ArrayContains(remaining_, value);
+    if (remaining_->is_empty() || !remaining_contains_value) {
+      remaining_->Add(value);
+    }
   }
 }
 
@@ -4879,125 +4776,16 @@ bool OutSet::Get(unsigned value) const {
   } else if (remaining_ == NULL) {
     return false;
   } else {
-    return remaining_->Contains(value);
+    return ArrayContains(remaining_, value);
   }
 }
 
 
-const uc16 DispatchTable::Config::kNoKey = unibrow::Utf8::kBadChar;
-
-
-void DispatchTable::AddRange(CharacterRange full_range, int value,
-                             Zone* zone) {
-  CharacterRange current = full_range;
-  if (tree()->is_empty()) {
-    // If this is the first range we just insert into the table.
-    ZoneSplayTree<Config>::Locator loc;
-    DCHECK_RESULT(tree()->Insert(current.from(), &loc));
-    loc.set_value(Entry(current.from(), current.to(),
-                        empty()->Extend(value, zone)));
-    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
-    // or after the start point of the range we're adding.
-    if (entry->from() < current.from() && entry->to() >= current.from()) {
-      // Snap the overlapping range in half around the start point of
-      // the range we're adding.
-      CharacterRange left(entry->from(), current.from() - 1);
-      CharacterRange right(current.from(), entry->to());
-      // The left part of the overlapping range doesn't overlap.
-      // Truncate the whole entry to be just the left part.
-      entry->set_to(left.to());
-      // The right part is the one that overlaps.  We add this part
-      // to the map and let the next step deal with merging it with
-      // the range we're adding.
-      ZoneSplayTree<Config>::Locator loc;
-      DCHECK_RESULT(tree()->Insert(right.from(), &loc));
-      loc.set_value(Entry(right.from(),
-                          right.to(),
-                          entry->out_set()));
-    }
-  }
-  while (current.is_valid()) {
-    if (tree()->FindLeastGreaterThan(current.from(), &loc) &&
-        (loc.value().from() <= current.to()) &&
-        (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;
-        DCHECK_RESULT(tree()->Insert(current.from(), &ins));
-        ins.set_value(Entry(current.from(),
-                            entry->from() - 1,
-                            empty()->Extend(value, zone)));
-        current.set_from(entry->from());
-      }
-      DCHECK_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;
-        DCHECK_RESULT(tree()->Insert(current.to() + 1, &ins));
-        ins.set_value(Entry(current.to() + 1,
-                            entry->to(),
-                            entry->out_set()));
-        entry->set_to(current.to());
-      }
-      DCHECK(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, zone);
-      // Bail out if the last interval ended at 0xFFFF since otherwise
-      // adding 1 will wrap around to 0.
-      if (entry->to() == String::kMaxUtf16CodeUnit)
-        break;
-      DCHECK(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;
-      DCHECK_RESULT(tree()->Insert(current.from(), &ins));
-      ins.set_value(Entry(current.from(),
-                          current.to(),
-                          empty()->Extend(value, zone)));
-      break;
-    }
-  }
-}
-
-
-OutSet* DispatchTable::Get(uc16 value) {
-  ZoneSplayTree<Config>::Locator loc;
-  if (!tree()->FindGreatestLessThan(value, &loc))
-    return empty();
-  Entry* entry = &loc.value();
-  if (value <= entry->to())
-    return entry->out_set();
-  else
-    return empty();
-}
-
-
 // -------------------------------------------------------------------
 // Analysis
 
 
 void Analysis::EnsureAnalyzed(RegExpNode* that) {
-  StackLimitCheck check(that->zone()->isolate());
-  if (check.HasOverflowed()) {
-    fail("Stack overflow");
-    return;
-  }
   if (that->info()->been_analyzed || that->info()->being_analyzed)
     return;
   that->info()->being_analyzed = true;
@@ -5013,12 +4801,12 @@ void Analysis::VisitEnd(EndNode* that) {
 
 
 void TextNode::CalculateOffsets() {
-  int element_count = elements()->length();
+  intptr_t element_count = elements()->length();
   // Set up the offsets of the elements relative to the start.  This is a fixed
   // quantity since a TextNode can only contain fixed-width things.
-  int cp_offset = 0;
-  for (int i = 0; i < element_count; i++) {
-    TextElement& elm = elements()->at(i);
+  intptr_t cp_offset = 0;
+  for (intptr_t i = 0; i < element_count; i++) {
+    TextElement& elm = (*elements())[i];
     elm.set_cp_offset(cp_offset);
     cp_offset += elm.length();
   }
@@ -5049,8 +4837,8 @@ void Analysis::VisitAction(ActionNode* that) {
 
 void Analysis::VisitChoice(ChoiceNode* that) {
   NodeInfo* info = that->info();
-  for (int i = 0; i < that->alternatives()->length(); i++) {
-    RegExpNode* node = that->alternatives()->at(i).node();
+  for (intptr_t i = 0; i < that->alternatives()->length(); i++) {
+    RegExpNode* node = (*that->alternatives())[i].node();
     EnsureAnalyzed(node);
     if (has_failed()) return;
     // Anything the following nodes need to know has to be known by
@@ -5062,8 +4850,8 @@ void Analysis::VisitChoice(ChoiceNode* that) {
 
 void Analysis::VisitLoopChoice(LoopChoiceNode* that) {
   NodeInfo* info = that->info();
-  for (int i = 0; i < that->alternatives()->length(); i++) {
-    RegExpNode* node = that->alternatives()->at(i).node();
+  for (intptr_t i = 0; i < that->alternatives()->length(); i++) {
+    RegExpNode* node = (*that->alternatives())[i].node();
     if (node != that->loop_node()) {
       EnsureAnalyzed(node);
       if (has_failed()) return;
@@ -5089,8 +4877,8 @@ void Analysis::VisitAssertion(AssertionNode* that) {
 }
 
 
-void BackReferenceNode::FillInBMInfo(int offset,
-                                     int budget,
+void BackReferenceNode::FillInBMInfo(intptr_t offset,
+                                     intptr_t budget,
                                      BoyerMooreLookahead* bm,
                                      bool not_at_start) {
   // Working out the set of characters that a backreference can match is too
@@ -5100,18 +4888,18 @@ void BackReferenceNode::FillInBMInfo(int offset,
 }
 
 
-STATIC_ASSERT(BoyerMoorePositionInfo::kMapSize ==
-              RegExpMacroAssembler::kTableSize);
+COMPILE_ASSERT(BoyerMoorePositionInfo::kMapSize ==
+               RegExpMacroAssembler::kTableSize);
 
 
-void ChoiceNode::FillInBMInfo(int offset,
-                              int budget,
+void ChoiceNode::FillInBMInfo(intptr_t offset,
+                              intptr_t budget,
                               BoyerMooreLookahead* bm,
                               bool not_at_start) {
-  ZoneList<GuardedAlternative>* alts = alternatives();
+  ZoneGrowableArray<GuardedAlternative>* alts = alternatives();
   budget = (budget - 1) / alts->length();
-  for (int i = 0; i < alts->length(); i++) {
-    GuardedAlternative& alt = alts->at(i);
+  for (intptr_t i = 0; i < alts->length(); i++) {
+    GuardedAlternative& alt = (*alts)[i];
     if (alt.guards() != NULL && alt.guards()->length() != 0) {
       bm->SetRest(offset);  // Give up trying to fill in info.
       SaveBMInfo(bm, not_at_start, offset);
@@ -5123,35 +4911,34 @@ void ChoiceNode::FillInBMInfo(int offset,
 }
 
 
-void TextNode::FillInBMInfo(int initial_offset,
-                            int budget,
+void TextNode::FillInBMInfo(intptr_t initial_offset,
+                            intptr_t budget,
                             BoyerMooreLookahead* bm,
                             bool not_at_start) {
   if (initial_offset >= bm->length()) return;
-  int offset = initial_offset;
-  int max_char = bm->max_char();
-  for (int i = 0; i < elements()->length(); i++) {
+  intptr_t offset = initial_offset;
+  intptr_t max_char = bm->max_char();
+  for (intptr_t i = 0; i < elements()->length(); i++) {
     if (offset >= bm->length()) {
       if (initial_offset == 0) set_bm_info(not_at_start, bm);
       return;
     }
-    TextElement text = elements()->at(i);
+    TextElement text = elements()->At(i);
     if (text.text_type() == TextElement::ATOM) {
       RegExpAtom* atom = text.atom();
-      for (int j = 0; j < atom->length(); j++, offset++) {
+      for (intptr_t j = 0; j < atom->length(); j++, offset++) {
         if (offset >= bm->length()) {
           if (initial_offset == 0) set_bm_info(not_at_start, bm);
           return;
         }
-        uc16 character = atom->data()[j];
+        uint16_t character = atom->data()->At(j);
         if (bm->compiler()->ignore_case()) {
-          unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
-          int length = GetCaseIndependentLetters(
-              Isolate::Current(),
+          int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
+          intptr_t length = GetCaseIndependentLetters(
               character,
-              bm->max_char() == String::kMaxOneByteCharCode,
+              bm->max_char() == Symbols::kMaxOneCharCodeSymbol,
               chars);
-          for (int j = 0; j < length; j++) {
+          for (intptr_t j = 0; j < length; j++) {
             bm->Set(offset, chars[j]);
           }
         } else {
@@ -5159,16 +4946,17 @@ void TextNode::FillInBMInfo(int initial_offset,
         }
       }
     } else {
-      DCHECK_EQ(TextElement::CHAR_CLASS, text.text_type());
+      ASSERT(text.text_type() == TextElement::CHAR_CLASS);
       RegExpCharacterClass* char_class = text.char_class();
-      ZoneList<CharacterRange>* ranges = char_class->ranges(zone());
+      ZoneGrowableArray<CharacterRange>* ranges = char_class->ranges();
       if (char_class->is_negated()) {
         bm->SetAll(offset);
       } else {
-        for (int k = 0; k < ranges->length(); k++) {
-          CharacterRange& range = ranges->at(k);
+        for (intptr_t k = 0; k < ranges->length(); k++) {
+          CharacterRange& range = (*ranges)[k];
           if (range.from() > max_char) continue;
-          int to = Min(max_char, static_cast<int>(range.to()));
+          intptr_t to = Utils::Minimum(max_char,
+                                       static_cast<intptr_t>(range.to()));
           bm->SetInterval(offset, Interval(range.from(), to));
         }
       }
@@ -5187,159 +4975,54 @@ void TextNode::FillInBMInfo(int initial_offset,
 }
 
 
-// -------------------------------------------------------------------
-// Dispatch table construction
-
-
-void DispatchTableConstructor::VisitEnd(EndNode* that) {
-  AddRange(CharacterRange::Everything());
-}
-
-
-void DispatchTableConstructor::BuildTable(ChoiceNode* node) {
-  node->set_being_calculated(true);
-  ZoneList<GuardedAlternative>* alternatives = node->alternatives();
-  for (int i = 0; i < alternatives->length(); i++) {
-    set_choice_index(i);
-    alternatives->at(i).node()->Accept(this);
-  }
-  node->set_being_calculated(false);
-}
-
-
-class AddDispatchRange {
- public:
-  explicit AddDispatchRange(DispatchTableConstructor* constructor)
-    : constructor_(constructor) { }
-  void Call(uc32 from, DispatchTable::Entry entry);
- private:
-  DispatchTableConstructor* constructor_;
-};
-
-
-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_);
-  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());
-}
-
-
-void DispatchTableConstructor::VisitAssertion(AssertionNode* that) {
-  RegExpNode* target = that->on_success();
-  target->Accept(this);
-}
-
-
-static int CompareRangeByFrom(const CharacterRange* a,
-                              const CharacterRange* b) {
-  return Compare<uc16>(a->from(), b->from());
-}
-
-
-void DispatchTableConstructor::AddInverse(ZoneList<CharacterRange>* ranges) {
-  ranges->Sort(CompareRangeByFrom);
-  uc16 last = 0;
-  for (int i = 0; i < ranges->length(); i++) {
-    CharacterRange range = ranges->at(i);
-    if (last < range.from())
-      AddRange(CharacterRange(last, range.from() - 1));
-    if (range.to() >= last) {
-      if (range.to() == String::kMaxUtf16CodeUnit) {
-        return;
-      } else {
-        last = range.to() + 1;
-      }
-    }
-  }
-  AddRange(CharacterRange(last, String::kMaxUtf16CodeUnit));
-}
-
-
-void DispatchTableConstructor::VisitText(TextNode* that) {
-  TextElement elm = that->elements()->at(0);
-  switch (elm.text_type()) {
-    case TextElement::ATOM: {
-      uc16 c = elm.atom()->data()[0];
-      AddRange(CharacterRange(c, c));
-      break;
-    }
-    case TextElement::CHAR_CLASS: {
-      RegExpCharacterClass* tree = elm.char_class();
-      ZoneList<CharacterRange>* ranges = tree->ranges(that->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_global,
-    bool is_multiline, bool is_sticky, Handle<String> pattern,
-    Handle<String> sample_subject, bool is_one_byte, Zone* zone) {
-  if ((data->capture_count + 1) * 2 - 1 > RegExpMacroAssembler::kMaxRegister) {
-    return IrregexpRegExpTooBig(zone->isolate());
-  }
-  RegExpCompiler compiler(data->capture_count, ignore_case, is_one_byte, zone);
-
-  // Sample some characters from the middle of the string.
-  static const int kSampleSize = 128;
-
-  sample_subject = String::Flatten(sample_subject);
-  int chars_sampled = 0;
-  int half_way = (sample_subject->length() - kSampleSize) / 2;
-  for (int i = Max(0, half_way);
-       i < sample_subject->length() && chars_sampled < kSampleSize;
-       i++, chars_sampled++) {
-    compiler.frequency_collator()->CountCharacter(sample_subject->Get(i));
-  }
+    RegExpCompileData* data,
+    const ParsedFunction* parsed_function,
+    const ZoneGrowableArray<const ICData*>& ic_data_array) {
+  Isolate* isolate = Isolate::Current();
+
+  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());
+
+  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
+  // issues. We do not want to store subject strings in the regexp object since
+  // they might be long and we should not prevent their garbage collection.
+  // Passing them to this function explicitly does not help, since we must
+  // generate exactly the same IR for both the unoptimizing and optimizing
+  // pipelines (otherwise it gets confused when i.e. deopt id's differ).
+  // An option would be to store sampling results in the regexp object, but
+  // I'm not sure the performance gains are relevant enough.
 
   // 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 && !is_sticky) {
+  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 or sticky.
+    // this expression is anchored at the beginning.
     RegExpNode* loop_node =
         RegExpQuantifier::ToNode(0,
                                  RegExpTree::kInfinity,
                                  false,
-                                 new(zone) RegExpCharacterClass('*'),
+                                 new(isolate) RegExpCharacterClass('*'),
                                  &compiler,
                                  captured_body,
                                  data->contains_anchor);
@@ -5347,10 +5030,11 @@ RegExpEngine::CompilationResult RegExpEngine::Compile(
     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(zone) ChoiceNode(2, zone);
+      ChoiceNode* first_step_node = new(isolate) ChoiceNode(2, isolate);
       first_step_node->AddAlternative(GuardedAlternative(captured_body));
       first_step_node->AddAlternative(GuardedAlternative(
-          new(zone) TextNode(new(zone) RegExpCharacterClass('*'), loop_node)));
+          new(isolate) TextNode(
+              new(isolate) RegExpCharacterClass('*'), loop_node)));
       node = first_step_node;
     } else {
       node = loop_node;
@@ -5365,74 +5049,124 @@ RegExpEngine::CompilationResult RegExpEngine::Compile(
     }
   }
 
-  if (node == NULL) node = new(zone) EndNode(EndNode::BACKTRACK, zone);
+  if (node == NULL) node = new(isolate) EndNode(EndNode::BACKTRACK, isolate);
   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(zone->isolate(), error_message);
+    return CompilationResult(error_message);
   }
 
-  // Create the correct assembler for the architecture.
-#ifndef V8_INTERPRETED_REGEXP
   // Native regexp implementation.
 
-  NativeRegExpMacroAssembler::Mode mode =
-      is_one_byte ? NativeRegExpMacroAssembler::LATIN1
-                  : NativeRegExpMacroAssembler::UC16;
-
-#if V8_TARGET_ARCH_IA32
-  RegExpMacroAssemblerIA32 macro_assembler(mode, (data->capture_count + 1) * 2,
-                                           zone);
-#elif V8_TARGET_ARCH_X64
-  RegExpMacroAssemblerX64 macro_assembler(mode, (data->capture_count + 1) * 2,
-                                          zone);
-#elif V8_TARGET_ARCH_ARM
-  RegExpMacroAssemblerARM macro_assembler(mode, (data->capture_count + 1) * 2,
-                                          zone);
-#elif V8_TARGET_ARCH_ARM64
-  RegExpMacroAssemblerARM64 macro_assembler(mode, (data->capture_count + 1) * 2,
-                                            zone);
-#elif V8_TARGET_ARCH_MIPS
-  RegExpMacroAssemblerMIPS macro_assembler(mode, (data->capture_count + 1) * 2,
-                                           zone);
-#elif V8_TARGET_ARCH_MIPS64
-  RegExpMacroAssemblerMIPS macro_assembler(mode, (data->capture_count + 1) * 2,
-                                           zone);
-#elif V8_TARGET_ARCH_X87
-  RegExpMacroAssemblerX87 macro_assembler(mode, (data->capture_count + 1) * 2,
-                                          zone);
-#else
-#error "Unsupported architecture"
-#endif
-
-#else  // V8_INTERPRETED_REGEXP
-  // Interpreted regexp implementation.
-  EmbeddedVector<byte, 1024> codes;
-  RegExpMacroAssemblerIrregexp macro_assembler(codes, zone);
-#endif  // V8_INTERPRETED_REGEXP
+  IRRegExpMacroAssembler* macro_assembler =
+      new(isolate) IRRegExpMacroAssembler(specialization_cid,
+                                          data->capture_count,
+                                          parsed_function,
+                                          ic_data_array,
+                                          isolate);
 
   // Inserted here, instead of in Assembler, because it depends on information
   // in the AST that isn't replicated in the Node structure.
-  static const int kMaxBacksearchLimit = 1024;
+  static const intptr_t kMaxBacksearchLimit = 1024;
   if (is_end_anchored &&
       !is_start_anchored &&
       max_length < kMaxBacksearchLimit) {
-    macro_assembler.SetCurrentPositionFromEnd(max_length);
+    macro_assembler->SetCurrentPositionFromEnd(max_length);
   }
 
   if (is_global) {
-    macro_assembler.set_global_mode(
+    macro_assembler->set_global_mode(
         (data->tree->min_match() > 0)
             ? RegExpMacroAssembler::GLOBAL_NO_ZERO_LENGTH_CHECK
             : RegExpMacroAssembler::GLOBAL);
   }
 
-  return compiler.Assemble(&macro_assembler,
-                           node,
-                           data->capture_count,
-                           pattern);
+  RegExpEngine::CompilationResult result =
+      compiler.Assemble(macro_assembler,
+                        node,
+                        data->capture_count,
+                        pattern);
+
+  if (FLAG_trace_irregexp) {
+    macro_assembler->PrintBlocks();
+  }
+
+  return result;
 }
 
+
+static void CreateSpecializedFunction(Isolate* isolate,
+                                      const JSRegExp& regexp,
+                                      intptr_t specialization_cid,
+                                      const Object& owner) {
+  const intptr_t kParamCount = RegExpMacroAssembler::kParamCount;
+
+  Function& fn = Function::Handle(isolate,
+        Function::New(String::Handle(isolate, Symbols::New("RegExp")),

[Ivan Posva, 2014/11/05 07:55:09]

Please predefine this symbol.

[zerny-google, 2014/11/05 11:52:00]

Done.

[Ivan Posva, 2014/11/07 08:46:54]

Actually looking at this a bit more "RegExp" is really a bad name for these
functions as it is too close to the constructor name and will like lead to
confusion at some point. A suggestion that I can come up with immediately is to
name this function ":irregexp" which is an illegal identifier and thus ensures
that these functions cannot be called directly from Dart code. See for example
Function::NewEvalFunction.

[zerny-google, 2014/11/10 09:10:42]

Done.

+                      RawFunction::kIrregexpFunction,
+                      true,   // Static.
+                      false,  // Not const.
+                      false,  // Not abstract.
+                      false,  // Not external.
+                      false,  // Not native.
+                      owner,
+                      0));  // Requires a non-negative 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,
+                                                           Heap::kOld)));
+  fn.set_parameter_names(Array::Handle(isolate, Array::New(kParamCount,
+                                                           Heap::kOld)));
+  fn.SetParameterTypeAt(0, Type::Handle(isolate, Type::DynamicType()));
+  fn.SetParameterNameAt(0, Symbols::string_param_());
+  fn.SetParameterTypeAt(1, Type::Handle(isolate, Type::DynamicType()));
+  fn.SetParameterNameAt(1, Symbols::start_index_param_());
+  fn.set_result_type(Type::Handle(isolate, Type::ArrayType()));
+
+  // Cache the result.
+  regexp.set_function(specialization_cid, fn);
+
+  fn.set_regexp(regexp);
+  fn.set_regexp_cid(specialization_cid);
+
+  // The function is compiled lazily during the first call.
+}
+
+
+RawJSRegExp* RegExpEngine::CreateJSRegExp(Isolate* isolate,
+                                          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 Class& owner = Class::Handle(isolate,
+        lib.LookupClass(String::Handle(isolate, Symbols::New("RegExp"))));

[Ivan Posva, 2014/11/05 07:55:09]

diito for the symbol

But the question is really why we are "adding" the irregexp functions to the
RegExp class.

[zerny-google, 2014/11/05 11:52:00]

AFAIK we don't allow a non-existent owner, so setting the RegExp class as the
owner seems natural. I can see some other generated functions use
Type::Function().type_class(). Would that be better?

Access to the functions only takes place through the JSRegExp object.

[Ivan Posva, 2014/11/07 08:46:54]

I was considering whether it would simplify things if we made these closures
instead of functions as they are stored in instance fields, but came to the
realization that it would not solve any of the naming and hook up to owner
issues.

[zerny-google, 2014/11/10 09:10:42]

Ok. In that case, I've left the RegExp class as the owner.

+
+  CreateSpecializedFunction(isolate, regexp, kOneByteStringCid, owner);
+  CreateSpecializedFunction(isolate, regexp, kTwoByteStringCid, owner);
+  CreateSpecializedFunction(isolate, regexp, kExternalOneByteStringCid, owner);
+  CreateSpecializedFunction(isolate, regexp, kExternalTwoByteStringCid, owner);
+
+  return regexp.raw();
+}
+
+
 }  // namespace dart