Turn more explicitly named temps into uses of definitions.

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/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 1539 matching lines @@
                          node->function(),
                          node->arguments()->names(),
                          values);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   // Context is saved around the call, it's treated as an extra operand
   // consumed by the call (but not an argument).
-  AddInstruction(new BindInstr(temp_index(), new CurrentContextComp()));
+  BindInstr* context = new BindInstr(temp_index(), new CurrentContextComp());
+  AddInstruction(context);
 
   ArgumentGraphVisitor for_closure(owner(), temp_index() + 1);
   node->closure()->Visit(&for_closure);
   Append(for_closure);
 
   ZoneGrowableArray<Value*>* arguments =
       new ZoneGrowableArray<Value*>(node->arguments()->length());
   arguments->Add(for_closure.value());
   TranslateArgumentList(*node->arguments(), temp_index() + 2, arguments);
   // First operand is the saved context, consumed by the call.
   ClosureCallComp* call =  new ClosureCallComp(node,
                                                owner()->try_index(),
-                                               new TempVal(temp_index()),
+                                               new UseVal(context),
                                                arguments);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
-  AddInstruction(new BindInstr(temp_index(), new CurrentContextComp()));
-  TempVal* ctx = new TempVal(temp_index());
-  AddInstruction(new BindInstr(temp_index(),
-                 new CloneContextComp(node->id(),
-                                      node->token_index(),
-                                      owner()->try_index(),
-                                      ctx)));
-  TempVal* cloned_ctx = new TempVal(temp_index());
-  ReturnComputation(new StoreContextComp(cloned_ctx));
+  BindInstr* context = new BindInstr(temp_index(), new CurrentContextComp());
+  AddInstruction(context);
+  BindInstr* clone =
+      new BindInstr(temp_index(),
+                    new CloneContextComp(node->id(),
+                                         node->token_index(),
+                                         owner()->try_index(),
+                                         new UseVal(context)));
+  AddInstruction(clone);
+  ReturnComputation(new StoreContextComp(new UseVal(clone)));
 }
 
 
 TempVal* EffectGraphVisitor::BuildObjectAllocation(ConstructorCallNode* node,
                                                    int start_index) {
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
 
   ZoneGrowableArray<Value*>* allocate_arguments =
       new ZoneGrowableArray<Value*>();
@@ skipping 418 matching lines @@
 }
 
 
 bool EffectGraphVisitor::MustSaveRestoreContext(SequenceNode* node) const {
   return (node == owner()->parsed_function().node_sequence()) &&
          (owner()->parsed_function().saved_context_var() != NULL);
 }
 
 
 void EffectGraphVisitor::UnchainContext() {
-  AddInstruction(new BindInstr(temp_index(), new CurrentContextComp()));
-  TempVal* temp_ctx = new TempVal(temp_index());
-  NativeLoadFieldComp* load = new NativeLoadFieldComp(
-      temp_ctx, Context::parent_offset());
-  AddInstruction(new BindInstr(temp_index(), load));
-  TempVal* parent_ctx = new TempVal(temp_index());
-  AddInstruction(new DoInstr(new StoreContextComp(parent_ctx)));
+  BindInstr* context = new BindInstr(temp_index(), new CurrentContextComp());
+  AddInstruction(context);
+  BindInstr* parent =
+      new BindInstr(temp_index(),
+                    new NativeLoadFieldComp(
+                        new UseVal(context), Context::parent_offset()));
+  AddInstruction(parent);
+  AddInstruction(new DoInstr(new StoreContextComp(new UseVal(parent))));
 }
 
 
 // <Statement> ::= Sequence { scope: LocalScope
 //                            nodes: <Statement>*
 //                            label: SourceLabel }
 void EffectGraphVisitor::VisitSequenceNode(SequenceNode* node) {
   LocalScope* scope = node->scope();
   const intptr_t num_context_variables =
       (scope != NULL) ? scope->num_context_variables() : 0;
   int previous_context_level = owner()->context_level();
   if (num_context_variables > 0) {
     // The loop local scope declares variables that are captured.
     // Allocate and chain a new context.
     // Allocate context computation (uses current CTX)
-    AllocateContextComp* comp = new AllocateContextComp(
-        node->token_index(),
-        owner()->try_index(),
-        num_context_variables);
-    AddInstruction(new BindInstr(temp_index(), comp));
-    Value* allocated_context_value = new TempVal(temp_index());
+    BindInstr* allocated_context =
+        new BindInstr(temp_index(),
+                      new AllocateContextComp(node->token_index(),
+                                              owner()->try_index(),
+                                              num_context_variables));
+    AddInstruction(allocated_context);
 
     // If this node_sequence is the body of the function being compiled, and if
     // this function is not a closure, do not link the current context as the
     // parent of the newly allocated context, as it is not accessible. Instead,
     // save it in a pre-allocated variable and restore it on exit.
     if (MustSaveRestoreContext(node)) {
-      AddInstruction(new BindInstr(temp_index() + 1, new CurrentContextComp()));
+      BindInstr* current_context =
+          new BindInstr(temp_index() + 1, new CurrentContextComp());
+      AddInstruction(current_context);
       StoreLocalComp* store_local = new StoreLocalComp(
           *owner()->parsed_function().saved_context_var(),
-          new TempVal(temp_index() + 1),
+          new UseVal(current_context),
           0);
       AddInstruction(new DoInstr(store_local));
       StoreContextComp* store_context =
           new StoreContextComp(new ConstantVal(Object::ZoneHandle()));
       AddInstruction(new DoInstr(store_context));
     }
 
-    ChainContextComp* chain_context = new ChainContextComp(
-        allocated_context_value);
+    ChainContextComp* chain_context =
+        new ChainContextComp(new UseVal(allocated_context));
     AddInstruction(new DoInstr(chain_context));
     owner()->set_context_level(scope->context_level());
 
     // If this node_sequence is the body of the function being compiled, copy
     // the captured parameters from the frame into the context.
     if (node == owner()->parsed_function().node_sequence()) {
       ASSERT(scope->context_level() == 1);
       const Function& function = owner()->parsed_function().function();
       const int num_params = function.NumberOfParameters();
       int param_frame_index =
           (num_params == function.num_fixed_parameters()) ? 1 + num_params : -1;
       for (int pos = 0; pos < num_params; param_frame_index--, pos++) {
         const LocalVariable& parameter = *scope->VariableAt(pos);
         ASSERT(parameter.owner() == scope);
         if (parameter.is_captured()) {
           // Create a temporary local describing the original position.
           const String& temp_name = String::ZoneHandle(String::Concat(
               parameter.name(), String::Handle(String::NewSymbol("-orig"))));
           LocalVariable* temp_local = new LocalVariable(
               0,  // Token index.
               temp_name,
               Type::ZoneHandle(Type::DynamicType()));  // Type.
           temp_local->set_index(param_frame_index);
 
           // Copy parameter from local frame to current context.
-          LoadLocalComp* load_comp = new LoadLocalComp(
-              *temp_local, owner()->context_level());
-          AddInstruction(new BindInstr(temp_index(), load_comp));
+          BindInstr* load =
+              new BindInstr(temp_index(),
+                            new LoadLocalComp(*temp_local,
+                                              owner()->context_level()));
+          AddInstruction(load);
           StoreLocalComp* store_local = new StoreLocalComp(
               parameter,
-              new TempVal(temp_index()),
+              new UseVal(load),
               owner()->context_level());
           AddInstruction(new DoInstr(store_local));
           // Write NULL to the source location to detect buggy accesses and
           // allow GC of passed value if it gets overwritten by a new value in
           // the function.
           StoreLocalComp* clear_local = new StoreLocalComp(
               *temp_local,
               new ConstantVal(Object::ZoneHandle()),
               owner()->context_level());
           AddInstruction(new DoInstr(clear_local));
         }
       }
     }
   }
 
   if (FLAG_enable_type_checks &&
       (node == owner()->parsed_function().node_sequence())) {
     const int num_params =
         owner()->parsed_function().function().NumberOfParameters();
     for (int pos = 0; pos < num_params; pos++) {
       const LocalVariable& parameter = *scope->VariableAt(pos);
       ASSERT(parameter.owner() == scope);
       if (!CanSkipTypeCheck(NULL, parameter.type())) {
-        LoadLocalComp* load = new LoadLocalComp(parameter,
-                                                owner()->context_level());
-        AddInstruction(new BindInstr(temp_index(), load));
-        TempVal* argument_value = new TempVal(temp_index());
+        BindInstr* load =
+            new BindInstr(temp_index(),
+                          new LoadLocalComp(parameter,
+                                            owner()->context_level()));
+        AddInstruction(load);
         BuildAssertAssignable(node->ParameterIdAt(pos),
                               parameter.token_index(),
-                              argument_value,
+                              new UseVal(load),
                               parameter.type(),
                               parameter.name(),
                               temp_index());
       }
     }
   }
 
   intptr_t i = 0;
   while (is_open() && (i < node->length())) {
     EffectGraphVisitor for_effect(owner(), temp_index());
@@ skipping 699 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