Set instruction/use_index when adding an input to an IL instruction.

runtime/vm/intermediate_language.cc

 // Copyright (c) 2013, 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/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 52 matching lines @@
 
 bool Value::Equals(Value* other) const {
   return definition() == other->definition();
 }
 
 
 CheckClassInstr::CheckClassInstr(Value* value,
                                  intptr_t deopt_id,
                                  const ICData& unary_checks)
     : unary_checks_(unary_checks) {
-  ASSERT(value != NULL);
   ASSERT(unary_checks.IsZoneHandle());
   // Expected useful check data.
-  ASSERT(!unary_checks_.IsNull() &&
-         (unary_checks_.NumberOfChecks() > 0) &&
-         (unary_checks_.num_args_tested() == 1));
-  inputs_[0] = value;
+  ASSERT(!unary_checks_.IsNull());
+  ASSERT(unary_checks_.NumberOfChecks() > 0);
+  ASSERT(unary_checks_.num_args_tested() == 1);
+  SetInputAt(0, value);
   deopt_id_ = deopt_id;
   // Otherwise use CheckSmiInstr.
   ASSERT((unary_checks_.NumberOfChecks() != 1) ||
          (unary_checks_.GetReceiverClassIdAt(0) != kSmiCid));
 }
 
 
 bool CheckClassInstr::AttributesEqual(Instruction* other) const {
   CheckClassInstr* other_check = other->AsCheckClass();
   ASSERT(other_check != NULL);
@@ skipping 438 matching lines @@
   }
 }
 
 
 void Definition::ReplaceWith(Definition* other,
                              ForwardInstructionIterator* iterator) {
   // Record other's input uses.
   for (intptr_t i = other->InputCount() - 1; i >= 0; --i) {
     Value* input = other->InputAt(i);
     input->definition()->AddInputUse(input);
-    input->set_instruction(other);
-    input->set_use_index(i);
   }
   // Take other's environment from this definition.
   ASSERT(other->env() == NULL);
   intptr_t use_index = 0;
   for (Environment::DeepIterator it(env()); !it.Done(); it.Advance()) {
     Value* use = it.CurrentValue();
     use->set_instruction(other);
     use->set_use_index(use_index++);
   }
   other->set_env(env());
@@ skipping 13 matching lines @@
     other->LinkTo(this);
     iterator->RemoveCurrentFromGraph();
   } else {
     other->LinkTo(next());
   }
   set_previous(NULL);
   set_next(NULL);
 }
 
 
+BranchInstr::BranchInstr(ComparisonInstr* comparison, bool is_checked)
+    : comparison_(comparison), is_checked_(is_checked) {
+  for (intptr_t i = comparison->InputCount() - 1; i >= 0; --i) {

[Vyacheslav Egorov (Google), 2013/02/22 16:13:36]

Why are we going backwards?

Seems like a micro-optimization.

[Kevin Millikin (Google), 2013/02/25 11:08:07]

I disagree.

+    comparison->InputAt(i)->set_instruction(this);
+  }
+}
+
+
+void BranchInstr::RawSetInputAt(intptr_t i, Value* value) {
+  comparison()->SetInputAt(i, value);

[Vyacheslav Egorov (Google), 2013/02/22 16:13:36]

I think here you should delegate to RawSetInputAt.

[Kevin Millikin (Google), 2013/02/25 11:08:07]

Oops, OK.

It's always seemed arbitrary (and more complicated) to me that the branch steals
ownership of the inputs from the comparison.  That the code above works suggests
that nobody depends on the current behavior.

+}
+
+
 // A misleadingly named function for use in template functions that replace
 // both definitions with definitions and branch comparisons with
 // comparisons.  In the branch case, leave the branch intact and replace its
 // comparison with another comparison.
 void BranchInstr::ReplaceWith(ComparisonInstr* other,
                               ForwardInstructionIterator* ignored) {
   // Record the new comparison's input uses.
   for (intptr_t i = other->InputCount() - 1; i >= 0; --i) {
     Value* input = other->InputAt(i);
     input->definition()->AddInputUse(input);
   }
   SetComparison(other);
 }
 
 
 void BranchInstr::SetComparison(ComparisonInstr* comp) {
   // The new comparison's input uses are already recorded in their
   // definition's use lists.
   for (intptr_t i = comp->InputCount() - 1; i >= 0; --i) {
-    Value* input = comp->InputAt(i);
-    input->set_instruction(this);
-    input->set_use_index(i);
+    comp->InputAt(i)->set_instruction(this);
   }
   // There should be no need to copy or unuse an environment.
   ASSERT(comparison()->env() == NULL);
   // Remove the current comparison's input uses.
   comparison()->UnuseAllInputs();
   ASSERT(!comp->HasUses());
   comparison_ = comp;
 }
 
 
@@ skipping 143 matching lines @@
       PhiInstr* phi = (*join->phis())[i];
       if (phi == NULL) continue;
       ASSERT(pred_count == phi->InputCount());
       // Save the predecessor use.
       Value* pred_use = phi->InputAt(old_index);
       // Move uses between old and new.
       intptr_t step = (old_index < new_index) ? 1 : -1;
       for (intptr_t use_idx = old_index;
            use_idx != new_index;
            use_idx += step) {
-        Value* use = phi->InputAt(use_idx + step);
-        phi->SetInputAt(use_idx, use);
-        use->set_use_index(use_idx);
+        phi->SetInputAt(use_idx, phi->InputAt(use_idx + step));
       }
       // Write the predecessor use.
       phi->SetInputAt(new_index, pred_use);
-      pred_use->set_use_index(new_index);
     }
   }
 }
 
 
 void JoinEntryInstr::InsertPhi(intptr_t var_index, intptr_t var_count) {
   // Lazily initialize the array of phis.
   // Currently, phis are stored in a sparse array that holds the phi
   // for variable with index i at position i.
   // TODO(fschneider): Store phis in a more compact way.
@@ skipping 1389 matching lines @@
     case kExternalUint8ArrayCid:
     case kExternalUint8ClampedArrayCid:
       return ByteArray::length_offset();
     default:
       UNREACHABLE();
       return -1;
   }
 }
 
 
+InvokeMathCFunctionInstr::InvokeMathCFunctionInstr(
+    ZoneGrowableArray<Value*>* inputs,
+    InstanceCallInstr* instance_call,
+    MethodRecognizer::Kind recognized_kind)
+    : inputs_(inputs),
+      locs_(NULL),
+      recognized_kind_(recognized_kind) {
+  ASSERT(inputs_->length() == ArgumentCountFor(recognized_kind_));
+  for (intptr_t i = 0; i < inputs_->length(); ++i) {
+    ASSERT((*inputs)[i] != NULL);
+    (*inputs)[i]->set_instruction(this);
+    (*inputs)[i]->set_use_index(i);
+  }
+  deopt_id_ = instance_call->deopt_id();
+}
+
+
 intptr_t InvokeMathCFunctionInstr::ArgumentCountFor(
     MethodRecognizer::Kind kind) {
   switch (kind) {
     case MethodRecognizer::kDoubleTruncate:
     case MethodRecognizer::kDoubleRound:
     case MethodRecognizer::kDoubleFloor:
     case MethodRecognizer::kDoubleCeil: {
       ASSERT(!CPUFeatures::double_truncate_round_supported());
       return 1;
     }
@@ skipping 52 matching lines @@
     default:
       UNREACHABLE();
   }
   return kPowRuntimeEntry;
 }
 
 
 #undef __
 
 }  // namespace dart