Turn definitions that do not produce results (e.g. Checks) into instructions.

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/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/scopes.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, enable_type_checks);
 
 
-intptr_t Definition::Hashcode() const {
+intptr_t Instruction::Hashcode() const {
   intptr_t result = tag();
   for (intptr_t i = 0; i < InputCount(); ++i) {
     Value* value = InputAt(i);
     intptr_t j = value->definition()->ssa_temp_index();
     result = result * 31 + j;
   }
   return result;
 }
 
 
-bool Definition::Equals(Definition* other) const {
+bool Instruction::Equals(Instruction* other) const {
   if (tag() != other->tag()) return false;
   for (intptr_t i = 0; i < InputCount(); ++i) {
     if (!InputAt(i)->Equals(other->InputAt(i))) return false;
   }
   return AttributesEqual(other);
 }
 
 
 bool Value::Equals(Value* other) const {
   return definition() == other->definition();
 }
 
 
-bool CheckClassInstr::AttributesEqual(Definition* other) const {
+bool CheckClassInstr::AttributesEqual(Instruction* other) const {
   CheckClassInstr* other_check = other->AsCheckClass();
   ASSERT(other_check != NULL);
   if (unary_checks().NumberOfChecks() !=
       other_check->unary_checks().NumberOfChecks()) {
     return false;
   }
   for (intptr_t i = 0; i < unary_checks().NumberOfChecks(); ++i) {
     // TODO(fschneider): Make sure ic_data are sorted to hit more cases.
     if (unary_checks().GetReceiverClassIdAt(i) !=
         other_check->unary_checks().GetReceiverClassIdAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
-bool CheckArrayBoundInstr::AttributesEqual(Definition* other) const {
+bool CheckArrayBoundInstr::AttributesEqual(Instruction* other) const {
   CheckArrayBoundInstr* other_check = other->AsCheckArrayBound();
   ASSERT(other_check != NULL);
   return array_type() == other_check->array_type();
 }
 
 
-bool StrictCompareInstr::AttributesEqual(Definition* other) const {
+bool StrictCompareInstr::AttributesEqual(Instruction* other) const {
   StrictCompareInstr* other_op = other->AsStrictCompare();
   ASSERT(other_op != NULL);
   return kind() == other_op->kind();
 }
 
 
-bool BinarySmiOpInstr::AttributesEqual(Definition* other) const {
+bool BinarySmiOpInstr::AttributesEqual(Instruction* other) const {
   BinarySmiOpInstr* other_op = other->AsBinarySmiOp();
   ASSERT(other_op != NULL);
   return op_kind() == other_op->op_kind();
 }
 
 
-bool LoadFieldInstr::AttributesEqual(Definition* other) const {
+bool LoadFieldInstr::AttributesEqual(Instruction* other) const {
   LoadFieldInstr* other_load = other->AsLoadField();
   ASSERT(other_load != NULL);
   ASSERT((offset_in_bytes() != other_load->offset_in_bytes()) ||
          ((immutable_ == other_load->immutable_) &&
           (ResultCid() == other_load->ResultCid())));
   return offset_in_bytes() == other_load->offset_in_bytes();
 }
 
 
-bool LoadStaticFieldInstr::AttributesEqual(Definition* other) const {
+bool LoadStaticFieldInstr::AttributesEqual(Instruction* other) const {
   LoadStaticFieldInstr* other_load = other->AsLoadStaticField();
   ASSERT(other_load != NULL);
   // Assert that the field is initialized.
   ASSERT(field().value() != Object::sentinel());
   ASSERT(field().value() != Object::transition_sentinel());
   return field().raw() == other_load->field().raw();
 }
 
 
-bool ConstantInstr::AttributesEqual(Definition* other) const {
+bool ConstantInstr::AttributesEqual(Instruction* other) const {
   ConstantInstr* other_constant = other->AsConstant();
   ASSERT(other_constant != NULL);
   return (value().raw() == other_constant->value().raw());
 }
 
 
 // Returns true if the value represents a constant.
 bool Value::BindsToConstant() const {
   return definition()->IsConstant();
 }
@@ skipping 98 matching lines @@
   prev_instr->set_next(next_instr);
   next_instr->set_previous(prev_instr);
   // Reset successor and previous instruction to indicate
   // that the instruction is removed from the graph.
   set_previous(NULL);
   set_next(NULL);
   return return_previous ? prev_instr : next_instr;
 }
 
 
-void Definition::InsertBefore(Instruction* next) {
+void Instruction::InsertBefore(Instruction* next) {
   ASSERT(previous_ == NULL);
   ASSERT(next_ == NULL);
   next_ = next;
   previous_ = next->previous_;
   next->previous_ = this;
   previous_->next_ = this;
 }
 
 
-void Definition::InsertAfter(Instruction* prev) {
+void Instruction::InsertAfter(Instruction* prev) {
   ASSERT(previous_ == NULL);
   ASSERT(next_ == NULL);
   previous_ = prev;
   next_ = prev->next_;
   next_->previous_ = this;
   previous_->next_ = this;
 }
 
 
-BlockEntryInstr* Definition::GetBlock() const {
+BlockEntryInstr* Instruction::GetBlock() const {
   // TODO(fschneider): Implement a faster way to get the block of an
   // instruction.
   ASSERT(previous() != NULL);
   Instruction* result = previous();
   while (!result->IsBlockEntry()) result = result->previous();
   return result->AsBlockEntry();
 }
 
 
 void ForwardInstructionIterator::RemoveCurrentFromGraph() {
@@ skipping 934 matching lines @@
 RawAbstractType* CheckArrayBoundInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
 RawAbstractType* CheckEitherNonSmiInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
-// Optimizations that eliminate or simplify individual computations.
+// Optimizations that eliminate or simplify individual instructions.
+Instruction* Instruction::Canonicalize() {
+  return this;
+}
+
+
 Definition* Definition::Canonicalize() {
   return this;
 }
 
 
 Definition* StrictCompareInstr::Canonicalize() {
   if (!right()->BindsToConstant()) return this;
   const Object& right_constant = right()->BoundConstant();
   Definition* left_defn = left()->definition();
   // TODO(fschneider): Handle other cases: e === false and e !== true/false.
   // Handles e === true.
   if ((kind() == Token::kEQ_STRICT) &&
       (right_constant.raw() == Bool::True()) &&
       (left()->ResultCid() == kBoolCid)) {
     // Return left subexpression as the replacement for this instruction.
     return left_defn;
   }
   return this;
 }
 
 
-Definition* CheckClassInstr::Canonicalize() {
+Instruction* CheckClassInstr::Canonicalize() {
   const intptr_t v_cid = value()->ResultCid();
   const intptr_t num_checks = unary_checks().NumberOfChecks();
   if ((num_checks == 1) &&
       (v_cid == unary_checks().GetReceiverClassIdAt(0))) {
     // No checks needed.
     return NULL;
   }
   return this;
 }
 
 
-Definition* CheckSmiInstr::Canonicalize() {
+Instruction* CheckSmiInstr::Canonicalize() {
   return (value()->ResultCid() == kSmiCid) ?  NULL : this;
 }
 
 
-Definition* CheckEitherNonSmiInstr::Canonicalize() {
+Instruction* CheckEitherNonSmiInstr::Canonicalize() {
   if ((left()->ResultCid() == kDoubleCid) ||
       (right()->ResultCid() == kDoubleCid)) {
     return NULL;  // Remove from the graph.
   }
   return this;
 }
 
 
 // Shared code generation methods (EmitNativeCode, MakeLocationSummary, and
 // PrepareEntry). Only assembly code that can be shared across all architectures
@@ skipping 495 matching lines @@
     value->set_use_index(use_index++);
     value->AddToEnvUseList();
   }
   instr->env()->outer_ = copy;
 }
 
 
 #undef __
 
 }  // namespace dart