First step toward an optimizing compiler:

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 41 matching lines @@
     exit()->SetSuccessor(other_fragment.entry());
     exit_ = other_fragment.exit();
   }
   temp_index_ = other_fragment.temp_index();
 }
 
 
 void EffectGraphVisitor::AddInstruction(Instruction* instruction) {
   ASSERT(is_open());
   DeallocateTempIndex(instruction->InputCount());
-  if (instruction->IsDefinition()) {
-    instruction->AsDefinition()->set_temp_index(AllocateTempIndex());
+  if (instruction->IsBindInstr()) {
+    instruction->AsBindInstr()->set_temp_index(AllocateTempIndex());
   }
   if (is_empty()) {
     entry_ = exit_ = instruction;
   } else {
     exit()->SetSuccessor(instruction);
     exit_ = instruction;
   }
 }
 
 
@@ skipping 519 matching lines @@
   ASSERT(instantiator_class.NumTypeParameters() > 0);
   instantiator = BuildInstantiator();
   if (instantiator == NULL) {
     // No instantiator when inside factory.
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_index, NULL);
   } else {
     // Preserve instantiator.
     const LocalVariable& expr_temp =
         *owner()->parsed_function().expression_temp_var();
-    Definition* saved =
+    BindInstr* saved =
         new BindInstr(BuildStoreLocal(expr_temp, instantiator));
     AddInstruction(saved);
     instantiator = new UseVal(saved);
-    Definition* loaded = new BindInstr(BuildLoadLocal(expr_temp));
+    BindInstr* loaded = new BindInstr(BuildLoadLocal(expr_temp));
     AddInstruction(loaded);
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_index, new UseVal(loaded));
   }
   *instantiator_result = instantiator;
   *instantiator_type_arguments_result = instantiator_type_arguments;
 }
 
 
 // Used for testing incoming arguments.
@@ skipping 25 matching lines @@
                                                 Value* value,
                                                 const AbstractType& dst_type,
                                                 const String& dst_name) {
   if (CanSkipTypeCheck(value, dst_type)) {
     return value;
   }
   AssertAssignableComp* comp = BuildAssertAssignable(token_index,
                                                      value,
                                                      dst_type,
                                                      dst_name);
-  Definition* assert_assignable = new BindInstr(comp);
+  BindInstr* assert_assignable = new BindInstr(comp);
   AddInstruction(assert_assignable);
   return new UseVal(assert_assignable);
 }
 
 
 void EffectGraphVisitor::BuildInstanceOf(ComparisonNode* node) {
   ASSERT(Token::IsInstanceofOperator(node->kind()));
   EffectGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
@@ skipping 100 matching lines @@
     Append(for_left_value);
     ValueGraphVisitor for_right_value(owner(), temp_index());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     EqualityCompareComp* comp = new EqualityCompareComp(
         node->token_index(), owner()->try_index(),
         for_left_value.value(), for_right_value.value());
     if (node->kind() == Token::kEQ) {
       ReturnComputation(comp);
     } else {
-      Definition* eq_result = new BindInstr(comp);
+      BindInstr* eq_result = new BindInstr(comp);
       AddInstruction(eq_result);
       if (FLAG_enable_type_checks) {
         eq_result =
             new BindInstr(new AssertBooleanComp(node->token_index(),
                                                 owner()->try_index(),
                                                 new UseVal(eq_result)));
         AddInstruction(eq_result);
       }
       BooleanNegateComp* negate = new BooleanNegateComp(new UseVal(eq_result));
       ReturnComputation(negate);
@@ skipping 634 matching lines @@
   AddInstruction(context);
   BindInstr* clone =
       new BindInstr(new CloneContextComp(node->token_index(),
                                          owner()->try_index(),
                                          new UseVal(context)));
   AddInstruction(clone);
   ReturnComputation(new StoreContextComp(new UseVal(clone)));
 }
 
 
-Definition* EffectGraphVisitor::BuildObjectAllocation(
+BindInstr* EffectGraphVisitor::BuildObjectAllocation(
     ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
 
   ZoneGrowableArray<Value*>* allocate_arguments =
       new ZoneGrowableArray<Value*>();
   if (requires_type_arguments) {
     BuildConstructorTypeArguments(node, allocate_arguments);
   }
   // In checked mode, if the type arguments are uninstantiated, they may need to
@@ skipping 65 matching lines @@
                            factory_arguments);
     ReturnComputation(call);
     return;
   }
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n+1, t_n+2, ...)
   // No need to preserve allocated value (simpler than in ValueGraphVisitor).
-  Definition* allocate = BuildObjectAllocation(node);
+  BindInstr* allocate = BuildObjectAllocation(node);
   BuildConstructorCall(node, new UseVal(allocate));
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiator() {
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().owner());
   if (instantiator_class.NumTypeParameters() == 0) {
     return NULL;
   }
@@ skipping 61 matching lines @@
   BindInstr* load =
       new BindInstr(new NativeLoadFieldComp(
                         instantiator,
                         type_arguments_instance_field_offset,
                         Type::ZoneHandle()));  // Not an instance, no type.
   AddInstruction(load);
   return new UseVal(load);
 }
 
 
-Definition* EffectGraphVisitor::BuildInstantiatedTypeArguments(
+BindInstr* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     intptr_t token_index,
     const AbstractTypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     BindInstr* type_args =
         new BindInstr(new ConstantVal(type_arguments));
     AddInstruction(type_args);
     return type_args;
   }
   // The type arguments are uninstantiated.
   Value* instantiator_value =
@@ skipping 35 matching lines @@
   //   t_n   <- t2
   //   t_n+1 <- t1
   // Use expression_temp_var and node->allocated_object_var() locals to keep
   // intermediate results around (t1 and t2 above).
   ASSERT(owner()->parsed_function().expression_temp_var() != NULL);
   const LocalVariable& t1 = *owner()->parsed_function().expression_temp_var();
   const LocalVariable& t2 = node->allocated_object_var();
   Value* instantiator_type_arguments = BuildInstantiatorTypeArguments(
       node->token_index(), NULL);
   ASSERT(instantiator_type_arguments->IsUse());
-  Definition* stored_instantiator = new BindInstr(
+  BindInstr* stored_instantiator = new BindInstr(
       BuildStoreLocal(t1, instantiator_type_arguments));
   AddInstruction(stored_instantiator);
   // t1: instantiator type arguments.
 
   BindInstr* extract_type_arguments = new BindInstr(
       new ExtractConstructorTypeArgumentsComp(
           node->token_index(),
           owner()->try_index(),
           node->type_arguments(),
           new UseVal(stored_instantiator)));
   AddInstruction(extract_type_arguments);
 
   Instruction* stored_type_arguments = new DoInstr(
       BuildStoreLocal(t2, new UseVal(extract_type_arguments)));
   AddInstruction(stored_type_arguments);
   // t2: extracted constructor type arguments.
-  Definition* load_instantiator = new BindInstr(BuildLoadLocal(t1));
+  BindInstr* load_instantiator = new BindInstr(BuildLoadLocal(t1));
   AddInstruction(load_instantiator);
 
   BindInstr* extract_instantiator =
       new BindInstr(new ExtractConstructorInstantiatorComp(
                         node,
                         new UseVal(load_instantiator)));
   AddInstruction(extract_instantiator);
   AddInstruction(new DoInstr(
       BuildStoreLocal(t1, new UseVal(extract_instantiator))));
   // t2: extracted constructor type arguments.
   // t1: extracted constructor instantiator.
-  Definition* load_0 = new BindInstr(BuildLoadLocal(t2));
+  BindInstr* load_0 = new BindInstr(BuildLoadLocal(t2));
   AddInstruction(load_0);
-  Definition* load_1 = new BindInstr(BuildLoadLocal(t1));
+  BindInstr* load_1 = new BindInstr(BuildLoadLocal(t1));
   AddInstruction(load_1);
   args->Add(new UseVal(load_0));
   args->Add(new UseVal(load_1));
 }
 
 
 void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     EffectGraphVisitor::VisitConstructorCallNode(node);
     return;
   }
 
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n      <- StoreLocal(temp, t_n);
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n, t_n+1, ...)
   //   tn       <- LoadLocal(temp)
 
-  Definition* allocate = BuildObjectAllocation(node);
+  BindInstr* allocate = BuildObjectAllocation(node);
   Computation* store_allocated = BuildStoreLocal(
       node->allocated_object_var(),
       new UseVal(allocate));
-  Definition* allocated_value = new BindInstr(store_allocated);
+  BindInstr* allocated_value = new BindInstr(store_allocated);
   AddInstruction(allocated_value);
   BuildConstructorCall(node, new UseVal(allocated_value));
   Computation* load_allocated = BuildLoadLocal(
       node->allocated_object_var());
   allocated_value = new BindInstr(load_allocated);
   AddInstruction(allocated_value);
   ReturnValue(new UseVal(allocated_value));
 }
 
 
@@ skipping 496 matching lines @@
   }
 }
 
 
 void FlowGraphBuilder::BuildGraph(bool for_optimized) {
   if (FLAG_print_ast) {
     // Print the function ast before IL generation.
     AstPrinter::PrintFunctionNodes(parsed_function());
   }
   // Compilation can be nested, preserve the computation-id.
-  Isolate* isolate = Isolate::Current();
-  const intptr_t prev_cid = isolate->computation_id();
-  isolate->set_computation_id(0);
   const Function& function = parsed_function().function();
   TargetEntryInstr* normal_entry = new TargetEntryInstr();
   graph_entry_ = new GraphEntryInstr(normal_entry);
   EffectGraphVisitor for_effect(this, 0);
   for_effect.AddInstruction(normal_entry);
   parsed_function().node_sequence()->Visit(&for_effect);
   // Check that the graph is properly terminated.
   ASSERT(!for_effect.is_open());
   GrowableArray<intptr_t> parent;
   GrowableArray<BitVector*> assigned_vars;
@@ skipping 10 matching lines @@
                                variable_count);
   // Number blocks in reverse postorder.
   intptr_t block_count = postorder_block_entries_.length();
   for (intptr_t i = 0; i < block_count; ++i) {
     postorder_block_entries_[i]->set_block_id(block_count - i - 1);
   }
   if (for_optimized) {
     GrowableArray<BitVector*> dominance_frontier;
     ComputeDominators(&preorder_block_entries_, &parent, &dominance_frontier);
   }
-  isolate->set_computation_id(prev_cid);
   if (FLAG_print_flow_graph) {
     intptr_t length = postorder_block_entries_.length();
     GrowableArray<BlockEntryInstr*> reverse_postorder(length);
     for (intptr_t i = length - 1; i >= 0; --i) {
       reverse_postorder.Add(postorder_block_entries_[i]);
     }
     FlowGraphPrinter printer(function, reverse_postorder);
     printer.PrintBlocks();
   }
 }
@@ skipping 129 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