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

runtime/vm/regexp_assembler.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/regexp_assembler.h"
 
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/il_printer.h"
 #include "vm/object_store.h"
 #include "vm/regexp.h"
 #include "vm/resolver.h"
 #include "vm/stack_frame.h"
 #include "vm/unibrow-inl.h"
 #include "vm/unicode.h"
 
-#define I isolate()
+#define Z zone()
 
 // Debugging output macros. TAG() is called at the head of each interesting
 // function and prints its name during execution if irregexp tracing is enabled.
 #define TAG() if (FLAG_trace_irregexp) { TAG_(); }
 #define TAG_() \
   Print(PushArgument( \
-    Bind(new(I) ConstantInstr(String::ZoneHandle(I, String::Concat( \
+    Bind(new(Z) ConstantInstr(String::ZoneHandle(Z, String::Concat( \
         String::Handle(String::New("TAG: ")), \
         String::Handle(String::New(__FUNCTION__)), Heap::kOld))))));
 
 #define PRINT(arg) if (FLAG_trace_irregexp) { Print(arg); }
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_irregexp, false, "Trace irregexps");
 
 
@@ skipping 24 matching lines @@
  * Results are returned though an array of capture indices, stored at
  * matches_param_. A null array specifies a failure to match. The match indices
  * [start_inclusive, end_exclusive] for capture group i are stored at positions
  * matches_param_[i * 2] and matches_param_[i * 2 + 1], respectively. Match
  * indices of -1 denote non-matched groups. Note that we store these indices
  * as a negative offset from the end of the string in registers_array_
  * during processing, and convert them to standard indexes when copying them
  * to matches_param_ on successful match.
  */
 
-RegExpMacroAssembler::RegExpMacroAssembler(Isolate* isolate)
+RegExpMacroAssembler::RegExpMacroAssembler(Zone* zone)
   : slow_safe_compiler_(false),
     global_mode_(NOT_GLOBAL),
-    isolate_(isolate) {
+    zone_(zone) {
 }
 
 
 RegExpMacroAssembler::~RegExpMacroAssembler() {
 }
 
 
 IRRegExpMacroAssembler::IRRegExpMacroAssembler(
     intptr_t specialization_cid,
     intptr_t capture_count,
     const ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
-    Isolate* isolate)
-    : RegExpMacroAssembler(isolate),
+    Zone* zone)
+    : RegExpMacroAssembler(zone),
       specialization_cid_(specialization_cid),
       parsed_function_(parsed_function),
       ic_data_array_(ic_data_array),
       current_instruction_(NULL),
       stack_(NULL),
       stack_pointer_(NULL),
       current_character_(NULL),
       current_position_(NULL),
       string_param_(NULL),
       string_param_length_(NULL),
       start_index_param_(NULL),
       registers_count_(0),
       saved_registers_count_((capture_count + 1) * 2),
-      stack_array_cell_(Array::ZoneHandle(isolate, Array::New(1, Heap::kOld))),
+      stack_array_cell_(Array::ZoneHandle(zone, Array::New(1, Heap::kOld))),
       // The registers array is allocated at a fixed size after assembly.
-      registers_array_(TypedData::ZoneHandle(isolate, TypedData::null())) {
+      registers_array_(TypedData::ZoneHandle(zone, TypedData::null())) {
   switch (specialization_cid) {
     case kOneByteStringCid:
     case kExternalOneByteStringCid: mode_ = ASCII; break;
     case kTwoByteStringCid:
     case kExternalTwoByteStringCid: mode_ = UC16; break;
     default: UNREACHABLE();
   }
 
   InitializeLocals();
 
   // Allocate an initial stack backing of the minimum stack size. The stack
   // backing is indirectly referred to so we can reuse it on subsequent matches
   // even in the case where the backing has been enlarged and thus reallocated.
-  stack_array_cell_.SetAt(0, TypedData::Handle(isolate,
+  stack_array_cell_.SetAt(0, TypedData::Handle(zone,
     TypedData::New(kTypedDataInt32ArrayCid, kMinStackSize / 4, Heap::kOld)));
 
   // Create and generate all preset blocks.
   entry_block_ =
-      new(isolate) GraphEntryInstr(
+      new(zone) GraphEntryInstr(
         *parsed_function_,
-        new(isolate) TargetEntryInstr(block_id_.Alloc(), kInvalidTryIndex),
+        new(zone) TargetEntryInstr(block_id_.Alloc(), kInvalidTryIndex),
         Isolate::kNoDeoptId);
   start_block_ =
-      new(isolate) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
+      new(zone) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
   success_block_ =
-      new(isolate) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
+      new(zone) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
   backtrack_block_ =
-      new(isolate) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
+      new(zone) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
   exit_block_ =
-      new(isolate) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
+      new(zone) JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex);
 
   GenerateEntryBlock();
   GenerateSuccessBlock();
   GenerateExitBlock();
 
   blocks_.Add(entry_block_);
   blocks_.Add(entry_block_->normal_entry());
   blocks_.Add(start_block_);
   blocks_.Add(success_block_);
   blocks_.Add(backtrack_block_);
@@ skipping 49 matching lines @@
 
   // Store (start_index - string.length) as the current position (since it's a
   // negative offset from the end of the string).
   PushArgumentInstr* start_index_push = PushLocal(start_index_param_);
   PushArgumentInstr* length_push = PushLocal(string_param_length_);
 
   StoreLocal(current_position_, Bind(Sub(start_index_push, length_push)));
 
   // Generate a local list variable to represent "registers" and
   // initialize capture registers (others remain garbage).
-  StoreLocal(registers_, Bind(new(I) ConstantInstr(registers_array_)));
+  StoreLocal(registers_, Bind(new(Z) ConstantInstr(registers_array_)));
   ClearRegisters(0, saved_registers_count_ - 1);
 
   // Generate a local list variable to represent the backtracking stack.
   PushArgumentInstr* stack_cell_push =
-      PushArgument(Bind(new(I) ConstantInstr(stack_array_cell_)));
+      PushArgument(Bind(new(Z) ConstantInstr(stack_array_cell_)));
   StoreLocal(stack_, Bind(InstanceCall(
       InstanceCallDescriptor::FromToken(Token::kINDEX),
       stack_cell_push,
       PushArgument(Bind(Uint64Constant(0))))));
   StoreLocal(stack_pointer_, Bind(Int64Constant(-1)));
 
   // Jump to the start block.
   current_instruction_->Goto(start_block_);
 }
 
 
 void IRRegExpMacroAssembler::GenerateBacktrackBlock() {
   set_current_instruction(backtrack_block_);
   TAG();
   CheckPreemption();
 
   const intptr_t entries_count = entry_block_->indirect_entries().length();
 
-  TypedData& offsets = TypedData::ZoneHandle(I,
+  TypedData& offsets = TypedData::ZoneHandle(Z,
       TypedData::New(kTypedDataInt32ArrayCid, entries_count, Heap::kOld));
 
   PushArgumentInstr* block_offsets_push =
-      PushArgument(Bind(new(I) ConstantInstr(offsets)));
+      PushArgument(Bind(new(Z) ConstantInstr(offsets)));
   PushArgumentInstr* block_id_push = PushArgument(Bind(PopStack()));
 
   Value* offset_value =
       Bind(InstanceCall(InstanceCallDescriptor::FromToken(Token::kINDEX),
                         block_offsets_push,
                         block_id_push));
 
-  backtrack_goto_ = new(I) IndirectGotoInstr(&offsets, offset_value);
+  backtrack_goto_ = new(Z) IndirectGotoInstr(&offsets, offset_value);
   CloseBlockWith(backtrack_goto_);
 
   // Add an edge from the "indirect" goto to each of the targets.
   for (intptr_t j = 0; j < entries_count; j++) {
     backtrack_goto_->AddSuccessor(
         TargetWithJoinGoto(entry_block_->indirect_entries().At(j)));
   }
 }
 
 
 void IRRegExpMacroAssembler::GenerateSuccessBlock() {
   set_current_instruction(success_block_);
   TAG();
 
-  Value* type = Bind(new(I) ConstantInstr(
-      TypeArguments::ZoneHandle(I, TypeArguments::null())));
+  Value* type = Bind(new(Z) ConstantInstr(
+      TypeArguments::ZoneHandle(Z, TypeArguments::null())));
   Value* length = Bind(Uint64Constant(saved_registers_count_));
-  Value* array = Bind(new(I) CreateArrayInstr(kNoSourcePos, type, length));
+  Value* array = Bind(new(Z) CreateArrayInstr(kNoSourcePos, type, length));
   StoreLocal(result_, array);
 
   // Store captured offsets in the `matches` parameter.
   for (intptr_t i = 0; i < saved_registers_count_; i++) {
     PushArgumentInstr* matches_push = PushLocal(result_);
     PushArgumentInstr* index_push = PushArgument(Bind(Uint64Constant(i)));
 
     // Convert negative offsets from the end of the string to string indices.
     // TODO(zerny): use positive offsets from the get-go.
     PushArgumentInstr* offset_push = PushArgument(LoadRegister(i));
     PushArgumentInstr* len_push = PushLocal(string_param_length_);
     PushArgumentInstr* value_push =
         PushArgument(Bind(Add(offset_push, len_push)));
 
     Do(InstanceCall(InstanceCallDescriptor::FromToken(Token::kASSIGN_INDEX),
                     matches_push,
                     index_push,
                     value_push));
   }
 
   // Print the result if tracing.
   PRINT(PushLocal(result_));
 
   // Return true on success.
-  AppendInstruction(new(I) ReturnInstr(kNoSourcePos, Bind(LoadLocal(result_))));
+  AppendInstruction(new(Z) ReturnInstr(kNoSourcePos, Bind(LoadLocal(result_))));
 }
 
 
 void IRRegExpMacroAssembler::GenerateExitBlock() {
   set_current_instruction(exit_block_);
   TAG();
 
   // Return false on failure.
-  AppendInstruction(new(I) ReturnInstr(kNoSourcePos, Bind(LoadLocal(result_))));
+  AppendInstruction(new(Z) ReturnInstr(kNoSourcePos, Bind(LoadLocal(result_))));
 }
 
 
 void IRRegExpMacroAssembler::FinalizeRegistersArray() {
   ASSERT(registers_count_ >= saved_registers_count_);
   registers_array_ =
       TypedData::New(kTypedDataInt32ArrayCid, registers_count_, Heap::kOld);
 }
 
 
@@ skipping 11 matching lines @@
 #endif
 bool IRRegExpMacroAssembler::CanReadUnaligned() {
   return kEnableUnalignedAccesses && !slow_safe();
 }
 
 
 RawArray* IRRegExpMacroAssembler::Execute(
     const Function& function,
     const String& input,
     const Smi& start_offset,
-    Isolate* isolate) {
+    Zone* zone) {
   // Create the argument list.
   const Array& args = Array::Handle(Array::New(2));
   args.SetAt(0, input);
   args.SetAt(1, start_offset);
 
   // And finally call the generated code.
 
   const Object& retval =
-      Object::Handle(isolate, DartEntry::InvokeFunction(function, args));
+      Object::Handle(zone, DartEntry::InvokeFunction(function, args));
   if (retval.IsError()) {
     const Error& error = Error::Cast(retval);
     OS::Print("%s\n", error.ToErrorCString());
     // Should never happen.
     UNREACHABLE();
   }
 
   if (retval.IsNull()) {
     return Array::null();
   }
@@ skipping 31 matching lines @@
         }
       }
     }
   }
   return Bool::True().raw();
 }
 
 
 LocalVariable* IRRegExpMacroAssembler::Parameter(const String& name,
                                                  intptr_t index) const {
-  const Type& local_type = Type::ZoneHandle(I, Type::DynamicType());
+  const Type& local_type = Type::ZoneHandle(Z, Type::DynamicType());
   LocalVariable* local =
-      new(I) LocalVariable(kNoSourcePos, name, local_type);
+      new(Z) LocalVariable(kNoSourcePos, name, local_type);
 
   intptr_t param_frame_index = kParamEndSlotFromFp + kParamCount - index;
   local->set_index(param_frame_index);
 
   return local;
 }
 
 
 LocalVariable* IRRegExpMacroAssembler::Local(const String& name) {
-  const Type& local_type = Type::ZoneHandle(I, Type::DynamicType());
+  const Type& local_type = Type::ZoneHandle(Z, Type::DynamicType());
   LocalVariable* local =
-      new(I) LocalVariable(kNoSourcePos, name, local_type);
+      new(Z) LocalVariable(kNoSourcePos, name, local_type);
   local->set_index(GetNextLocalIndex());
 
   return local;
 }
 
 
 ConstantInstr* IRRegExpMacroAssembler::Int64Constant(int64_t value) const {
-  return new(I) ConstantInstr(
-        Integer::ZoneHandle(I, Integer::New(value, Heap::kOld)));
+  return new(Z) ConstantInstr(
+        Integer::ZoneHandle(Z, Integer::New(value, Heap::kOld)));
 }
 
 
 ConstantInstr* IRRegExpMacroAssembler::Uint64Constant(uint64_t value) const {
-  return new(I) ConstantInstr(
-        Integer::ZoneHandle(I, Integer::NewFromUint64(value, Heap::kOld)));
+  return new(Z) ConstantInstr(
+        Integer::ZoneHandle(Z, Integer::NewFromUint64(value, Heap::kOld)));
 }
 
 
 ConstantInstr* IRRegExpMacroAssembler::BoolConstant(bool value) const {
-  return new(I) ConstantInstr(value ? Bool::True() : Bool::False());
+  return new(Z) ConstantInstr(value ? Bool::True() : Bool::False());
 }
 
 
 ConstantInstr* IRRegExpMacroAssembler::StringConstant(const char* value) const {
-  return new(I) ConstantInstr(
-        String::ZoneHandle(I, String::New(value, Heap::kOld)));
+  return new(Z) ConstantInstr(
+        String::ZoneHandle(Z, String::New(value, Heap::kOld)));
 }
 
 
 ConstantInstr* IRRegExpMacroAssembler::WordCharacterMapConstant() const {
-  const Library& lib = Library::Handle(I, Library::CoreLibrary());
-  const Class& regexp_class = Class::Handle(I,
+  const Library& lib = Library::Handle(Z, Library::CoreLibrary());
+  const Class& regexp_class = Class::Handle(Z,
         lib.LookupClassAllowPrivate(Symbols::JSSyntaxRegExp()));
-  const Field& word_character_field = Field::ZoneHandle(I,
+  const Field& word_character_field = Field::ZoneHandle(Z,
       regexp_class.LookupStaticField(Symbols::_wordCharacterMap()));
   ASSERT(!word_character_field.IsNull());
 
   if (word_character_field.IsUninitialized()) {
     word_character_field.EvaluateInitializer();
   }
   ASSERT(!word_character_field.IsUninitialized());
 
-  return new(I) ConstantInstr(
-        Instance::ZoneHandle(I, word_character_field.value()));
+  return new(Z) ConstantInstr(
+        Instance::ZoneHandle(Z, word_character_field.value()));
 }
 
 
 ComparisonInstr* IRRegExpMacroAssembler::Comparison(
     ComparisonKind kind, PushArgumentInstr* lhs, PushArgumentInstr* rhs) {
   Token::Kind strict_comparison = Token::kEQ_STRICT;
   Token::Kind intermediate_operator = Token::kILLEGAL;
   switch (kind) {
   case kEQ:
     intermediate_operator = Token::kEQ;
@@ skipping 20 matching lines @@
 
   ASSERT(intermediate_operator != Token::kILLEGAL);
 
   Value* lhs_value =
       Bind(InstanceCall(
              InstanceCallDescriptor::FromToken(intermediate_operator),
              lhs,
              rhs));
   Value* rhs_value = Bind(BoolConstant(true));
 
-  return new(I) StrictCompareInstr(
+  return new(Z) StrictCompareInstr(
       kNoSourcePos, strict_comparison, lhs_value, rhs_value, true);
 }
 
 ComparisonInstr* IRRegExpMacroAssembler::Comparison(
     ComparisonKind kind, Definition* lhs, Definition* rhs) {
   PushArgumentInstr* lhs_push = PushArgument(Bind(lhs));
   PushArgumentInstr* rhs_push = PushArgument(Bind(rhs));
   return Comparison(kind, lhs_push, rhs_push);
 }
 
 
 StaticCallInstr* IRRegExpMacroAssembler::StaticCall(
     const Function& function) const {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new(I) ZoneGrowableArray<PushArgumentInstr*>(0);
+      new(Z) ZoneGrowableArray<PushArgumentInstr*>(0);
   return StaticCall(function, arguments);
 }
 
 
 StaticCallInstr* IRRegExpMacroAssembler::StaticCall(
     const Function& function,
     PushArgumentInstr* arg1) const {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new(I) ZoneGrowableArray<PushArgumentInstr*>(1);
+      new(Z) ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(arg1);
 
   return StaticCall(function, arguments);
 }
 
 
 StaticCallInstr* IRRegExpMacroAssembler::StaticCall(
     const Function& function,
     PushArgumentInstr* arg1,
     PushArgumentInstr* arg2) const {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new(I) ZoneGrowableArray<PushArgumentInstr*>(2);
+      new(Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(arg1);
   arguments->Add(arg2);
 
   return StaticCall(function, arguments);
 }
 
 
 StaticCallInstr* IRRegExpMacroAssembler::StaticCall(
     const Function& function,
     ZoneGrowableArray<PushArgumentInstr*>* arguments) const {
-  return new(I) StaticCallInstr(kNoSourcePos,
+  return new(Z) StaticCallInstr(kNoSourcePos,
                                 function,
                                 Object::null_array(),
                                 arguments,
                                 ic_data_array_);
 }
 
 
 InstanceCallInstr* IRRegExpMacroAssembler::InstanceCall(
     const InstanceCallDescriptor& desc,
     PushArgumentInstr* arg1) const {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new(I) ZoneGrowableArray<PushArgumentInstr*>(1);
+      new(Z) ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(arg1);
 
   return InstanceCall(desc, arguments);
 }
 
 
 InstanceCallInstr* IRRegExpMacroAssembler::InstanceCall(
     const InstanceCallDescriptor& desc,
     PushArgumentInstr* arg1,
     PushArgumentInstr* arg2) const {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new(I) ZoneGrowableArray<PushArgumentInstr*>(2);
+      new(Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(arg1);
   arguments->Add(arg2);
 
   return InstanceCall(desc, arguments);
 }
 
 
 InstanceCallInstr* IRRegExpMacroAssembler::InstanceCall(
     const InstanceCallDescriptor& desc,
     PushArgumentInstr* arg1,
     PushArgumentInstr* arg2,
     PushArgumentInstr* arg3) const {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new(I) ZoneGrowableArray<PushArgumentInstr*>(3);
+      new(Z) ZoneGrowableArray<PushArgumentInstr*>(3);
   arguments->Add(arg1);
   arguments->Add(arg2);
   arguments->Add(arg3);
 
   return InstanceCall(desc, arguments);
 }
 
 
 InstanceCallInstr* IRRegExpMacroAssembler::InstanceCall(
     const InstanceCallDescriptor& desc,
     ZoneGrowableArray<PushArgumentInstr*> *arguments) const {
   return
-    new(I) InstanceCallInstr(kNoSourcePos,
+    new(Z) InstanceCallInstr(kNoSourcePos,
                              desc.name,
                              desc.token_kind,
                              arguments,
                              Object::null_array(),
                              desc.checked_argument_count,
                              ic_data_array_);
 }
 
 
 LoadLocalInstr* IRRegExpMacroAssembler::LoadLocal(LocalVariable* local) const {
-  return new(I) LoadLocalInstr(*local);
+  return new(Z) LoadLocalInstr(*local);
 }
 
 
 void IRRegExpMacroAssembler::StoreLocal(LocalVariable* local,
                                         Value* value) {
-  Do(new(I) StoreLocalInstr(*local, value));
+  Do(new(Z) StoreLocalInstr(*local, value));
 }
 
 
 void IRRegExpMacroAssembler::set_current_instruction(Instruction* instruction) {
   current_instruction_ = instruction;
 }
 
 
 Value* IRRegExpMacroAssembler::Bind(Definition* definition) {
   AppendInstruction(definition);
   definition->set_temp_index(temp_id_.Alloc());
 
-  return new(I) Value(definition);
+  return new(Z) Value(definition);
 }
 
 
 void IRRegExpMacroAssembler::Do(Definition* definition) {
   AppendInstruction(definition);
 }
 
 
 Value* IRRegExpMacroAssembler::BindLoadLocal(const LocalVariable& local) {
   if (local.IsConst()) {
-    return Bind(new(I) ConstantInstr(*local.ConstValue()));
+    return Bind(new(Z) ConstantInstr(*local.ConstValue()));
   }
   ASSERT(!local.is_captured());
-  return Bind(new(I) LoadLocalInstr(local));
+  return Bind(new(Z) LoadLocalInstr(local));
 }
 
 
 // In some cases, the V8 irregexp engine generates unreachable code by emitting
 // a jmp not followed by a bind. We cannot do the same, since it is impossible
 // to append to a block following a jmp. In such cases, assume that we are doing
 // the correct thing, but output a warning when tracing.
 #define HANDLE_DEAD_CODE_EMISSION() \
   if (current_instruction_ == NULL) { \
     if (FLAG_trace_irregexp) { \
@@ skipping 50 matching lines @@
 
   ASSERT(current_instruction_ != NULL);
   ASSERT(current_instruction_->next() == NULL);
   current_instruction_->Goto(to);
   set_current_instruction(NULL);
 }
 
 
 PushArgumentInstr* IRRegExpMacroAssembler::PushArgument(Value* value) {
   arg_id_.Alloc();
-  PushArgumentInstr* push = new(I) PushArgumentInstr(value);
+  PushArgumentInstr* push = new(Z) PushArgumentInstr(value);
   // Do *not* use Do() for push argument instructions.
   AppendInstruction(push);
   return push;
 }
 
 
 PushArgumentInstr* IRRegExpMacroAssembler::PushLocal(LocalVariable* local) {
   return PushArgument(Bind(LoadLocal(local)));
 }
 
 
 void IRRegExpMacroAssembler::Print(const char* str) {
   Print(PushArgument(
-    Bind(new(I) ConstantInstr(
-           String::ZoneHandle(I, String::New(str, Heap::kOld))))));
+    Bind(new(Z) ConstantInstr(
+           String::ZoneHandle(Z, String::New(str, Heap::kOld))))));
 }
 
 
 void IRRegExpMacroAssembler::Print(PushArgumentInstr* argument) {
   const Library& lib = Library::Handle(Library::CoreLibrary());
   const Function& print_fn = Function::ZoneHandle(
-        I, lib.LookupFunctionAllowPrivate(Symbols::print()));
+        Z, lib.LookupFunctionAllowPrivate(Symbols::print()));
   Do(StaticCall(print_fn, argument));
 }
 
 
 void IRRegExpMacroAssembler::PrintBlocks() {
   for (intptr_t i = 0; i < blocks_.length(); i++) {
     FlowGraphPrinter::PrintBlock(blocks_[i], false);
   }
 }
 
@@ skipping 327 matching lines @@
                       &loop);
   } else {
     ASSERT(mode_ == UC16);
 
     Value* string_value = Bind(LoadLocal(string_param_));
     Value* lhs_index_value = Bind(LoadLocal(match_start_index_));
     Value* rhs_index_value = Bind(LoadLocal(capture_start_index_));
     Value* length_value = Bind(LoadLocal(capture_length_));
 
     Definition* is_match_def =
-        new(I) CaseInsensitiveCompareUC16Instr(
+        new(Z) CaseInsensitiveCompareUC16Instr(
                             string_value,
                             lhs_index_value,
                             rhs_index_value,
                             length_value,
                             specialization_cid_);
 
     BranchOrBacktrack(Comparison(kNE, is_match_def, BoolConstant(true)),
                       on_no_match);
   }
 
@@ skipping 209 matching lines @@
                     on_not_in_range);
 }
 
 
 void IRRegExpMacroAssembler::CheckBitInTable(
     const TypedData& table,
     BlockLabel* on_bit_set) {
   TAG();
 
   PushArgumentInstr* table_push =
-      PushArgument(Bind(new(I) ConstantInstr(table)));
+      PushArgument(Bind(new(Z) ConstantInstr(table)));
   PushArgumentInstr* index_push = PushLocal(current_character_);
 
   if (mode_ != ASCII || kTableMask != Symbols::kMaxOneCharCodeSymbol) {
     PushArgumentInstr* mask_push =
         PushArgument(Bind(Uint64Constant(kTableSize - 1)));
     index_push = PushArgument(
           Bind(InstanceCall(InstanceCallDescriptor::FromToken(Token::kBIT_AND),
                             index_push,
                             mask_push)));
   }
@@ skipping 323 matching lines @@
   TAG();
   PushArgumentInstr* stack_push = PushLocal(stack_);
   PushArgumentInstr* length_push = PushArgument(Bind(InstanceCall(
       InstanceCallDescriptor(
           String::ZoneHandle(Field::GetterSymbol(Symbols::Length()))),
       stack_push)));
   PushArgumentInstr* capacity_push = PushArgument(Bind(Sub(
       length_push,
       PushArgument(Bind(Uint64Constant(stack_limit_slack()))))));
   PushArgumentInstr* stack_pointer_push = PushLocal(stack_pointer_);
-  BranchInstr* branch = new(I) BranchInstr(
+  BranchInstr* branch = new(Z) BranchInstr(
       Comparison(kGT, capacity_push, stack_pointer_push));
   CloseBlockWith(branch);
 
   BlockLabel grow_stack;
   BlockLabel fallthrough;
   *branch->true_successor_address() =
       TargetWithJoinGoto(fallthrough.block());
   *branch->false_successor_address() =
       TargetWithJoinGoto(grow_stack.block());
 
   BindBlock(&grow_stack);
   GrowStack();
 
   BindBlock(&fallthrough);
 }
 
 
 void IRRegExpMacroAssembler::GrowStack() {
   TAG();
-  Value* cell = Bind(new(I) ConstantInstr(stack_array_cell_));
-  StoreLocal(stack_, Bind(new(I) GrowRegExpStackInstr(cell)));
+  Value* cell = Bind(new(Z) ConstantInstr(stack_array_cell_));
+  StoreLocal(stack_, Bind(new(Z) GrowRegExpStackInstr(cell)));
 }
 
 
 void IRRegExpMacroAssembler::ReadCurrentPositionFromRegister(intptr_t reg) {
   TAG();
   StoreLocal(current_position_, LoadRegister(reg));
 }
 
 // Resets the tip of the stack to the value stored in reg.
 void IRRegExpMacroAssembler::ReadStackPointerFromRegister(intptr_t reg) {
@@ skipping 119 matching lines @@
   JoinEntryInstr* true_successor_block = backtrack_block_;
   if (true_successor != NULL) {
     true_successor->SetLinked();
     true_successor_block = true_successor->block();
   }
   ASSERT(true_successor_block != NULL);
 
   // If the condition is not true, fall through to a new block.
   BlockLabel fallthrough;
 
-  BranchInstr* branch = new(I) BranchInstr(comparison);
+  BranchInstr* branch = new(Z) BranchInstr(comparison);
   *branch->true_successor_address() =
       TargetWithJoinGoto(true_successor_block);
   *branch->false_successor_address() =
       TargetWithJoinGoto(fallthrough.block());
 
   CloseBlockWith(branch);
   BindBlock(&fallthrough);
 }
 
 
 TargetEntryInstr* IRRegExpMacroAssembler::TargetWithJoinGoto(
     JoinEntryInstr* dst) {
-  TargetEntryInstr* target = new(I) TargetEntryInstr(
+  TargetEntryInstr* target = new(Z) TargetEntryInstr(
           block_id_.Alloc(), kInvalidTryIndex);
   blocks_.Add(target);
 
-  target->AppendInstruction(new(I) GotoInstr(dst));
+  target->AppendInstruction(new(Z) GotoInstr(dst));
 
   return target;
 }
 
 
 IndirectEntryInstr* IRRegExpMacroAssembler::IndirectWithJoinGoto(
     JoinEntryInstr* dst) {
-  IndirectEntryInstr* target = new(I) IndirectEntryInstr(
+  IndirectEntryInstr* target = new(Z) IndirectEntryInstr(
           block_id_.Alloc(), indirect_id_.Alloc(), kInvalidTryIndex);
   blocks_.Add(target);
 
-  target->AppendInstruction(new(I) GotoInstr(dst));
+  target->AppendInstruction(new(Z) GotoInstr(dst));
 
   return target;
 }
 
 
 void IRRegExpMacroAssembler::CheckPreemption() {
   TAG();
-  AppendInstruction(new(I) CheckStackOverflowInstr(kNoSourcePos, 0));
+  AppendInstruction(new(Z) CheckStackOverflowInstr(kNoSourcePos, 0));
 }
 
 
 Definition* IRRegExpMacroAssembler::Add(
     PushArgumentInstr* lhs,
     PushArgumentInstr* rhs) {
   return InstanceCall(InstanceCallDescriptor::FromToken(Token::kADD), lhs, rhs);
 }
 
 
@@ skipping 56 matching lines @@
     } else if (specialization_cid_ == kExternalTwoByteStringCid) {
       external_offset = ExternalTwoByteString::external_data_offset();
       data_offset = RawExternalTwoByteString::ExternalData::data_offset();
     } else {
       UNREACHABLE();
     }
     // This pushes untagged values on the stack which are immediately consumed:
     // the first value is consumed to obtain the second value which is consumed
     // by LoadCodeUnitsAtInstr below.
     Value* external_val =
-        Bind(new(I) LoadUntaggedInstr(pattern_val, external_offset));
+        Bind(new(Z) LoadUntaggedInstr(pattern_val, external_offset));
     pattern_val =
-        Bind(new(I) LoadUntaggedInstr(external_val, data_offset));
+        Bind(new(Z) LoadUntaggedInstr(external_val, data_offset));
   }
 
   // Here pattern_val might be untagged so this must not trigger a GC.
   Value* index_val = BindLoadLocal(*index);
 
-  return Bind(new(I) LoadCodeUnitsInstr(
+  return Bind(new(Z) LoadCodeUnitsInstr(
       pattern_val,
       index_val,
       characters,
       specialization_cid_,
       Scanner::kNoSourcePos));
 }
 
 
 #undef __
 
 }  // namespace dart