Automatically assign temporary indices to definitions in the IL.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/object.h"
 #include "vm/os.h"
 #include "vm/scopes.h"
 
@@ skipping 74 matching lines @@
 void FlowGraphVisitor::VisitBlocks() {
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     Instruction* current = block_order_[i]->Accept(this);
     while ((current != NULL) && !current->IsBlockEntry()) {
       current = current->Accept(this);
     }
   }
 }
 
 
+// ==== Per-instruction input counts.
+intptr_t AssertAssignableComp::InputCount() const {
+  // Value and optional instantiator type arguments.
+  return (instantiator_type_arguments() == NULL) ? 1 : 2;
+}
+
+
+intptr_t InstanceOfComp::InputCount() const {
+  // Value and optional type_arguments.
+  return (type_arguments() == NULL) ? 1 : 2;
+}
+
+
+intptr_t CreateClosureComp::InputCount() const {
+  // Optional type arguments.
+  return (type_arguments() == NULL) ? 0 : 1;
+}
+
+
+intptr_t InstanceCallComp::InputCount() const {
+  return ArgumentCount();
+}
+
+
+intptr_t StaticCallComp::InputCount() const {
+  return ArgumentCount();
+}
+
+
+intptr_t ClosureCallComp::InputCount() const {
+  // Context and arguments.
+  return 1 + ArgumentCount();
+}
+
+
+intptr_t AllocateObjectComp::InputCount() const {
+  return arguments().length();
+}
+
+
+intptr_t AllocateObjectWithBoundsCheckComp::InputCount() const {
+  return arguments().length();
+}
+
+
+intptr_t CreateArrayComp::InputCount() const {
+  return ElementCount();
+}
+
+
+intptr_t BranchInstr::InputCount() const {
+  return 1;
+}
+
+
+intptr_t ReThrowInstr::InputCount() const {
+  return 2;
+}
+
+
+intptr_t ThrowInstr::InputCount() const {
+  return 1;
+}
+
+
+intptr_t ReturnInstr::InputCount() const {
+  return 1;
+}
+
+
+intptr_t BindInstr::InputCount() const {
+  return computation()->InputCount();
+}
+
+
+intptr_t DoInstr::InputCount() const {
+  return computation()->InputCount();
+}
+
+
+intptr_t TuckTempInstr::InputCount() const {
+  return 0;
+}
+
+
+intptr_t PickTempInstr::InputCount() const {
+  return 0;
+}
+
+
+intptr_t TargetEntryInstr::InputCount() const {
+  return 0;
+}
+
+
+intptr_t JoinEntryInstr::InputCount() const {
+  return 0;
+}
+
+
 // ==== Postorder graph traversal.
 void JoinEntryInstr::DiscoverBlocks(
     BlockEntryInstr* current_block,
     GrowableArray<BlockEntryInstr*>* preorder,
     GrowableArray<BlockEntryInstr*>* postorder,
     GrowableArray<intptr_t>* parent) {
   // The global graph entry is a TargetEntryInstr, so we can assume
   // current_block is non-null and preorder array is non-empty.
   ASSERT(current_block != NULL);
   ASSERT(!preorder->is_empty());
@@ skipping 85 matching lines @@
   // true/false order in reverse postorder used as the block ordering in the
   // nonoptimizing compiler.
   ASSERT(true_successor_ != NULL);
   ASSERT(false_successor_ != NULL);
   false_successor_->DiscoverBlocks(current_block, preorder, postorder, parent);
   true_successor_->DiscoverBlocks(current_block, preorder, postorder, parent);
 }
 
 
 }  // namespace dart