Cleanups.

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 "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/class_finalizer.h"
@@ skipping 231 matching lines @@
     intptr_t osr_id) :
         parsed_function_(parsed_function),
         ic_data_array_(ic_data_array),
         num_copied_params_(parsed_function->num_copied_params()),
         // All parameters are copied if any parameter is.
         num_non_copied_params_((num_copied_params_ == 0)
             ? parsed_function->function().num_fixed_parameters()
             : 0),
         num_stack_locals_(parsed_function->num_stack_locals()),
         exit_collector_(exit_collector),
-        guarded_fields_(new(I) ZoneGrowableArray<const Field*>()),
         last_used_block_id_(0),  // 0 is used for the graph entry.
         try_index_(CatchClauseNode::kInvalidTryIndex),
         catch_try_index_(CatchClauseNode::kInvalidTryIndex),
         loop_depth_(0),
         graph_entry_(NULL),
         temp_count_(0),
         args_pushed_(0),
         nesting_stack_(NULL),
         osr_id_(osr_id),
         jump_count_(0),
@@ skipping 498 matching lines @@
     ASSERT(delta >= 0);
     Value* context = Bind(BuildCurrentContext());
     while (delta-- > 0) {
       context = Bind(new(I) LoadFieldInstr(
           context, Context::parent_offset(), Type::ZoneHandle(I, Type::null()),
           Scanner::kNoSourcePos));
     }
     Value* tmp_val = Bind(new(I) LoadLocalInstr(*tmp_var));
     StoreInstanceFieldInstr* store =
         new(I) StoreInstanceFieldInstr(Context::variable_offset(local.index()),
-                                    context,
-                                    tmp_val,
-                                    kEmitStoreBarrier,
-                                    Scanner::kNoSourcePos);
+                                       context,
+                                       tmp_val,
+                                       kEmitStoreBarrier,
+                                       Scanner::kNoSourcePos);
     Do(store);
     return ExitTempLocalScope(tmp_var);
   } else {
     return new(I) StoreLocalInstr(local, value);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildLoadLocal(const LocalVariable& local) {
   if (local.IsConst()) {
@@ skipping 1522 matching lines @@
   // Visit body.
   for (intptr_t i = 0; i < node->nodes().length(); ++i) {
     EffectGraphVisitor for_effect(owner());
     node->nodes()[i]->Visit(&for_effect);
     Append(for_effect);
   }
 
   intptr_t num_temps = node->num_temps();
   if (num_temps > 0) {
     owner()->DeallocateTemps(num_temps);
-    Do(new(I) DropTempsInstr(num_temps));
+    Do(new(I) DropTempsInstr(num_temps, NULL));
   }
 }
 
 
 void ValueGraphVisitor::VisitLetNode(LetNode* node) {
   BuildLetTempExpressions(node);
 
   // Visit body.
   for (intptr_t i = 0; i < node->nodes().length() - 1; ++i) {
     EffectGraphVisitor for_effect(owner());
@@ skipping 1139 matching lines @@
   store_value = Bind(BuildStoreExprTemp(store_value));
   GuardFieldClassInstr* guard_field_class =
       new(I) GuardFieldClassInstr(store_value,
                                node->field(),
                                I->GetNextDeoptId());
   AddInstruction(guard_field_class);
 
   store_value = Bind(BuildLoadExprTemp());
   GuardFieldLengthInstr* guard_field_length =
       new(I) GuardFieldLengthInstr(store_value,
-                                node->field(),
-                                I->GetNextDeoptId());
+                                   node->field(),
+                                   I->GetNextDeoptId());
   AddInstruction(guard_field_length);
 
   store_value = Bind(BuildLoadExprTemp());
   StoreInstanceFieldInstr* store =
       new(I) StoreInstanceFieldInstr(node->field(),
                                      for_instance.value(),
                                      store_value,
                                      kEmitStoreBarrier,
                                      node->token_pos());
   store->set_is_initialization(true);  // Maybe initializing store.
@@ skipping 785 matching lines @@
   // Check that the graph is properly terminated.
   ASSERT(!for_effect.is_open());
 
   // When compiling for OSR, use a depth first search to prune instructions
   // unreachable from the OSR entry. Catch entries are always considered
   // reachable, even if they become unreachable after OSR.
   if (osr_id_ != Isolate::kNoDeoptId) {
     PruneUnreachable();
   }
 
-  FlowGraph* graph = new(I) FlowGraph(*this, graph_entry_, last_used_block_id_);
+  FlowGraph* graph =
+      new(I) FlowGraph(parsed_function(), graph_entry_, last_used_block_id_);
   return graph;
 }
 
 
 void FlowGraphBuilder::PruneUnreachable() {
   ASSERT(osr_id_ != Isolate::kNoDeoptId);
   BitVector* block_marks = new(I) BitVector(I, last_used_block_id_ + 1);
   bool found = graph_entry_->PruneUnreachable(this, graph_entry_, NULL, osr_id_,
                                               block_marks);
   ASSERT(found);
 }
 
 
 void FlowGraphBuilder::Bailout(const char* reason) const {
   const Function& function = parsed_function_->function();
   Report::MessageF(Report::kBailout,
                    Script::Handle(function.script()),
                    function.token_pos(),
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart