Revert "IR refactoring: reduce duplication related to MayThrow/AllowsCSE."

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/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
@@ skipping 91 matching lines @@
 
 static int LowestFirst(const intptr_t* a, const intptr_t* b) {
   return *a - *b;
 }
 
 
 CheckClassInstr::CheckClassInstr(Value* value,
                                  intptr_t deopt_id,
                                  const ICData& unary_checks,
                                  intptr_t token_pos)
-    : TemplateInstruction(deopt_id),
+    : TemplateInstruction<1>(deopt_id),
       unary_checks_(unary_checks),
       cids_(unary_checks.NumberOfChecks()),
       licm_hoisted_(false),
       token_pos_(token_pos) {
   ASSERT(unary_checks.IsZoneHandle());
   // Expected useful check data.
   ASSERT(!unary_checks_.IsNull());
   ASSERT(unary_checks_.NumberOfChecks() > 0);
   ASSERT(unary_checks_.NumArgsTested() == 1);
   SetInputAt(0, value);
@@ skipping 162 matching lines @@
   ASSERT(other_assert != NULL);
   // This predicate has to be commutative for DominatorBasedCSE to work.
   // TODO(fschneider): Eliminate more asserts with subtype relation.
   return dst_type().raw() == other_assert->dst_type().raw();
 }
 
 
 bool StrictCompareInstr::AttributesEqual(Instruction* other) const {
   StrictCompareInstr* other_op = other->AsStrictCompare();
   ASSERT(other_op != NULL);
-  return ComparisonInstr::AttributesEqual(other) &&
-    (needs_number_check() == other_op->needs_number_check());
+  return kind() == other_op->kind();
 }
 
 
 bool MathMinMaxInstr::AttributesEqual(Instruction* other) const {
   MathMinMaxInstr* other_op = other->AsMathMinMax();
   ASSERT(other_op != NULL);
   return (op_kind() == other_op->op_kind()) &&
       (result_cid() == other_op->result_cid());
 }
 
@@ skipping 47 matching lines @@
 }
 
 
 const Field& LoadStaticFieldInstr::StaticField() const {
   Field& field = Field::Handle();
   field ^= field_value()->BoundConstant().raw();
   return field;
 }
 
 
+EffectSet LoadIndexedInstr::Dependencies() const {
+  return EffectSet::All();
+}
+
+
+bool LoadIndexedInstr::AttributesEqual(Instruction* other) const {
+  LoadIndexedInstr* other_load = other->AsLoadIndexed();
+  ASSERT(other_load != NULL);
+  return class_id() == other_load->class_id();
+}
+
+
 ConstantInstr::ConstantInstr(const Object& value) : value_(value) {
   // Check that the value is not an incorrect Integer representation.
   ASSERT(!value.IsBigint() || !Bigint::Cast(value).FitsIntoSmi());
   ASSERT(!value.IsBigint() || !Bigint::Cast(value).FitsIntoInt64());
   ASSERT(!value.IsMint() || !Smi::IsValid(Mint::Cast(value).AsInt64Value()));
 }
 
 
 bool ConstantInstr::AttributesEqual(Instruction* other) const {
   ConstantInstr* other_constant = other->AsConstant();
@@ skipping 2656 matching lines @@
   return new TestCidsInstr(token_pos(),
                            kind(),
                            new_left,
                            cid_results(),
                            deopt_id());
 }
 
 
 bool TestCidsInstr::AttributesEqual(Instruction* other) const {
   TestCidsInstr* other_instr = other->AsTestCids();
-  if (!ComparisonInstr::AttributesEqual(other)) {
+  ASSERT(other != NULL);
+  if (kind() != other_instr->kind()) {
     return false;
   }
   if (cid_results().length() != other_instr->cid_results().length()) {
     return false;
   }
   for (intptr_t i = 0; i < cid_results().length(); i++) {
     if (cid_results()[i] != other_instr->cid_results()[i]) {
       return false;
     }
   }
@@ skipping 153 matching lines @@
       String::ZoneHandle(Symbols::New(String::Cast(result)));
   return flow_graph->GetConstant(concatenated);
 }
 
 
 InvokeMathCFunctionInstr::InvokeMathCFunctionInstr(
     ZoneGrowableArray<Value*>* inputs,
     intptr_t deopt_id,
     MethodRecognizer::Kind recognized_kind,
     intptr_t token_pos)
-    : PureDefinition(deopt_id),
+    : Definition(deopt_id),
       inputs_(inputs),
       recognized_kind_(recognized_kind),
       token_pos_(token_pos) {
   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);
   }
 }
@@ skipping 100 matching lines @@
     case kDoubleSquare:  return "double-square";
   }
   UNREACHABLE();
   return "";
 }
 
 
 MergedMathInstr::MergedMathInstr(ZoneGrowableArray<Value*>* inputs,
                                  intptr_t deopt_id,
                                  MergedMathInstr::Kind kind)
-    : PureDefinition(deopt_id),
+    : Definition(deopt_id),
       inputs_(inputs),
       kind_(kind) {
   ASSERT(inputs_->length() == InputCountFor(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);
   }
 }
 
@@ skipping 12 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart