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 "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 367 matching lines @@
   AddInstruction(new ReturnInstr(node->token_pos(), return_value));
   CloseFragment();
 }
 
 
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
 }
 
+
 void ValueGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   ReturnComputation(new ConstantVal(node->literal()));
 }
 
+
 // Type nodes only occur as the right-hand side of instanceof comparisons,
 // and they are handled specially in that context.
 void EffectGraphVisitor::VisitTypeNode(TypeNode* node) { UNREACHABLE(); }
 
 
 // Helper routine returning true if the static type of the given value is more
 // specific than the given dst_type.
 static bool IsStaticTypeMoreSpecific(Value* value,
                                      const AbstractType& dst_type) {
   ASSERT(!dst_type.IsMalformed());
@@ skipping 2126 matching lines @@
 
 
 void FlowGraphBuilder::Rename(intptr_t var_count) {
   // TODO(fschneider): Store var_count in the FlowGraphBuilder instead of
   // passing it around.
   // TODO(fschneider): Support catch-entry.
   if (graph_entry_->SuccessorCount() > 1) {
     Bailout("Catch-entry support in SSA.");
   }
   // TODO(fschneider): Support copied parameters.
-  if (parsed_function().copied_parameter_count()) {
+  if (parsed_function().copied_parameter_count() != 0) {
     Bailout("Copied parameter support in SSA");
   }
   ASSERT(var_count == (parsed_function().stack_local_count() +
                        parsed_function().function().num_fixed_parameters()));
 
   // Initialize start environment.
   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));
   }
 
   // All locals are initialized with #null.
   Value* null_value = new ConstantVal(Object::ZoneHandle());
   for (; i < var_count; i++) {
     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.
   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,
                                        GrowableArray<Value*>* env,
@@ skipping 24 matching lines @@
     // 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);
       env->RemoveLast();
-      if (v->AsUse()->definition()->IsBind() &&
-          v->AsUse()->definition()->AsBind()->computation()->IsLoadLocal()) {
-        Computation* comp = v->AsUse()->definition()->AsBind()->computation();
+      BindInstr* as_bind = v->AsUse()->definition()->AsBind();
+      if ((as_bind != NULL) && as_bind->computation()->IsLoadLocal()) {
+        Computation* comp = as_bind->computation();
         intptr_t index = comp->AsLoadLocal()->local().BitIndexIn(var_count);
         current->SetInputAt(i, CopyValue((*env)[index]));
       }
-      if (v->AsUse()->definition()->IsBind() &&
-          v->AsUse()->definition()->AsBind()->computation()->IsStoreLocal()) {
+      if ((as_bind != NULL) && as_bind->computation()->IsStoreLocal()) {
         // For each use of a StoreLocal: Replace it with the value from the
         // environment.
-        Computation* comp = v->AsUse()->definition()->AsBind()->computation();
+        Computation* comp = as_bind->computation();
         intptr_t index = comp->AsStoreLocal()->local().BitIndexIn(var_count);
         current->SetInputAt(i, CopyValue((*env)[index]));
       }
     }
 
     // 2b. Handle LoadLocal and StoreLocal.
     // For each LoadLocal: Remove it from the graph.
     // For each StoreLocal: Remove it from the graph and update the environment.
     BindInstr* bind = current->AsBind();
     if (bind != NULL) {
@@ skipping 34 matching lines @@
     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);
+    intptr_t pred_index = successor->IndexOfPredecessor(block_entry);
+    ASSERT(pred_index >= 0);
     if (successor->phis() != NULL) {
       for (intptr_t i = 0; i < successor->phis()->length(); ++i) {
         PhiInstr* phi = (*successor->phis())[i];
         if (phi != NULL) {
           // Rename input operand and make a copy if it is a UseVal.
           Value* new_val = (*env)[i]->IsUse()
               ? new UseVal((*env)[i]->AsUse()->definition())
               : (*env)[i];
           phi->SetInputAt(pred_index, new_val);
         }
@@ skipping 10 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