Cleanup usage of GrowableArrays in class Environment.

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, 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/flow_graph_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 2475 matching lines @@
     Bailout("Catch-entry support in SSA.");
   }
   // TODO(fschneider): Support copied parameters.
   if (parsed_function().copied_parameter_count()) {
     Bailout("Copied parameter support in SSA");
   }
   ASSERT(var_count == (parsed_function().stack_local_count() +
                        parsed_function().function().num_fixed_parameters()));
 
   // Initialize start environment.
-  ZoneGrowableArray<Value*>* start_env =
-      new ZoneGrowableArray<Value*>(var_count);
+  GrowableArray<Value*> start_env(var_count);
   intptr_t i = 0;
   for (; i < parsed_function().function().num_fixed_parameters(); ++i) {
     ParameterInstr* param = new ParameterInstr(i);
     param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
-    start_env->Add(new UseVal(param));
+    start_env.Add(new UseVal(param));
   }
 
   // All locals are initialized with #null.
   Value* null_value = new ConstantVal(Object::ZoneHandle());
   for (; i < var_count; i++) {
-    start_env->Add(null_value);
+    start_env.Add(null_value);
   }
   graph_entry_->set_start_env(new Environment(start_env));
 
   BlockEntryInstr* normal_entry = graph_entry_->SuccessorAt(0);
   ASSERT(normal_entry != NULL);  // Must have entry.
-  ZoneGrowableArray<Value*>* env = new ZoneGrowableArray<Value*>(var_count);
-  env->AddArray(*start_env);
-  RenameRecursive(normal_entry, env, var_count);
+  GrowableArray<Value*> env(var_count);
+  env.AddArray(start_env);
+  RenameRecursive(normal_entry, &env, var_count);
 }
 
 
 static intptr_t WhichPred(BlockEntryInstr* predecessor,
                           JoinEntryInstr* join_block) {
   for (intptr_t i = 0; i < join_block->PredecessorCount(); ++i) {
     if (join_block->PredecessorAt(i) == predecessor) return i;
   }
   UNREACHABLE();
   return -1;
 }
 
 
 // Helper to a copy a value iff it is a UseVal.
 static Value* CopyValue(Value* value) {
   return value->IsUse()
       ? new UseVal(value->AsUse()->definition())
       : value;
 }
 
 
 void FlowGraphBuilder::RenameRecursive(BlockEntryInstr* block_entry,
-                                       ZoneGrowableArray<Value*>* env,
+                                       GrowableArray<Value*>* env,
                                        intptr_t var_count) {
   // 1. Process phis first.
   if (block_entry->IsJoinEntry()) {
     JoinEntryInstr* join = block_entry->AsJoinEntry();
     if (join->phis() != NULL) {
       for (intptr_t i = 0; i < join->phis()->length(); ++i) {
         PhiInstr* phi = (*join->phis())[i];
         if (phi != NULL) {
           (*env)[i] = new UseVal(phi);
           phi->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
         }
       }
     }
   }
 
   // 2. Process normal instructions.
   for (ForwardInstructionIterator it(block_entry); !it.Done(); it.Advance()) {
     Instruction* current = it.Current();
     // Attach current environment to the instruction.
     // TODO(fschneider): Currently each instruction gets a full copy of the
     // enviroment. This should be optimized: Only instructions that can
     // deoptimize will should have uses of the environment values.
-    current->set_env(new Environment(env));
+    current->set_env(new Environment(*env));
 
     // 2a. Handle uses:
     // Update expression stack environment for each use.
     // For each use of a LoadLocal or StoreLocal: Replace it with the value
     // from the environment.
     for (intptr_t i = 0; i < current->InputCount(); ++i) {
       Value* v = current->InputAt(i);
       if (!v->IsUse()) continue;
       // Update expression stack.
       ASSERT(env->length() > var_count);
@@ skipping 45 matching lines @@
           bind->set_ssa_temp_index(alloc_ssa_temp_index());
           env->Add(new UseVal(bind));
         }
       }
     }
   }
 
   // 3. Process dominated blocks.
   for (intptr_t i = 0; i < block_entry->dominated_blocks().length(); ++i) {
     BlockEntryInstr* block = block_entry->dominated_blocks()[i];
-    ZoneGrowableArray<Value*>* new_env =
-        new ZoneGrowableArray<Value*>(env->length());
-    new_env->AddArray(*env);
-    RenameRecursive(block, new_env, var_count);
+    GrowableArray<Value*> new_env(env->length());
+    new_env.AddArray(*env);
+    RenameRecursive(block, &new_env, var_count);
   }
 
   // 4. Process successor block. We have edge-split form, so that only blocks
   // with one successor can have a join block as successor.
   if ((block_entry->last_instruction()->SuccessorCount() == 1) &&
       block_entry->last_instruction()->SuccessorAt(0)->IsJoinEntry()) {
     JoinEntryInstr* successor =
         block_entry->last_instruction()->SuccessorAt(0)->AsJoinEntry();
     intptr_t pred_index = WhichPred(block_entry, successor);
     if (successor->phis() != NULL) {
@@ skipping 19 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart