Refactor Instruction classes to use a template base class.

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_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 170 matching lines @@
 intptr_t AllocateObjectComp::InputCount() const {
   return arguments().length();
 }
 
 
 intptr_t AllocateObjectWithBoundsCheckComp::InputCount() const {
   return arguments().length();
 }
 
 
-intptr_t BranchInstr::InputCount() const {
-  return 2;
-}
-
-
-Value* BranchInstr::InputAt(intptr_t i) const {
-  if (i == 0) return left();
-  if (i == 1) return right();
-  UNREACHABLE();
-  return NULL;
-}
-
-
-void BranchInstr::SetInputAt(intptr_t i, Value* value) {
-  if (i == 0) {
-    left_ = value;
-  } else if (i == 1) {
-    right_ = value;
-  } else {
-    UNREACHABLE();
-  }
-}
-
-
-intptr_t ParallelMoveInstr::InputCount() const {
-  UNREACHABLE();
-  return 0;
-}
-
-
-Value* ParallelMoveInstr::InputAt(intptr_t i) const {
-  UNREACHABLE();
-  return NULL;
-}
-
-
-void ParallelMoveInstr::SetInputAt(intptr_t i, Value* value) {
-  UNREACHABLE();
-}
-
-
-intptr_t GotoInstr::InputCount() const {
-  return 0;
-}
-
-
-Value* GotoInstr::InputAt(intptr_t i) const {
-  UNREACHABLE();
-  return NULL;
-}
-
-
-void GotoInstr::SetInputAt(intptr_t i, Value* value) {
-  UNREACHABLE();
-}
-
-
-intptr_t PushArgumentInstr::InputCount() const {
-  return 1;
-}
-
-
-Value* PushArgumentInstr::InputAt(intptr_t i) const {
-  if (i == 0) return value();
-  UNREACHABLE();
-  return NULL;
-}
-
-
-void PushArgumentInstr::SetInputAt(intptr_t i, Value* value) {
-  if (i == 0) {
-    value_ = value;
-    return;
-  }
-  UNREACHABLE();
-}
-
-
-intptr_t ReturnInstr::InputCount() const {
-  return 1;
-}
-
-
-Value* ReturnInstr::InputAt(intptr_t i) const {
-  if (i == 0) return value();
-  UNREACHABLE();
-  return NULL;
-}
-
-
-void ReturnInstr::SetInputAt(intptr_t i, Value* value) {
-  if (i == 0) {
-    value_ = value;
-    return;
-  }
-  UNREACHABLE();
-}
-
-
-intptr_t BindInstr::InputCount() const {
-  return computation()->InputCount();
-}
-
-
-Value* BindInstr::InputAt(intptr_t i) const {
-  return computation()->InputAt(i);
-}
-
-
-void BindInstr::SetInputAt(intptr_t i, Value* value) {
-  computation()->SetInputAt(i, value);
-}
-
-
-intptr_t PhiInstr::InputCount() const {
-  return inputs_.length();
-}
-
-
-Value* PhiInstr::InputAt(intptr_t i) const {
-  return inputs_[i];
-}
-
-
-void PhiInstr::SetInputAt(intptr_t i, Value* value) {
-  inputs_[i] = value;
-}
-
-
 RawAbstractType* PhiInstr::StaticType() const {
   // TODO(regis): Return the least upper bound of the input static types.
   // It is much simpler to compute the least specific of the input static types,
   // and it may be good enough in practice.
   // Even better: we could keep the set of the input static types intact.
   AbstractType& least_specific_type =
       AbstractType::Handle(InputAt(0)->StaticType());
   AbstractType& input_type = AbstractType::Handle();
   for (intptr_t i = 1; i < InputCount(); i++) {
     input_type = InputAt(i)->StaticType();
     if (input_type.IsMoreSpecificThan(least_specific_type, NULL)) {
       // Type least_specific_type is less specific than input_type. No change.
     } else if (least_specific_type.IsMoreSpecificThan(input_type, NULL)) {
       // Type input_type is less specific than the current least_specific_type.
       least_specific_type = input_type.raw();
     } else {
       // The types are unrelated. No need to continue.
       least_specific_type = Type::ObjectType();
       break;
     }
   }
   return least_specific_type.raw();
 }
 
 
-intptr_t ParameterInstr::InputCount() const {
-  return 0;
-}
-
-
-Value* ParameterInstr::InputAt(intptr_t i) const {
-  UNREACHABLE();
-  return NULL;
-}
-
-
-void ParameterInstr::SetInputAt(intptr_t i, Value* value) {
-  UNREACHABLE();
-}
-
-
 RawAbstractType* ParameterInstr::StaticType() const {
   // TODO(regis): Can type feedback provide information about the static type
   // of a passed-in parameter?
   // Note that in checked mode, we could return the static type of the formal
   // parameter. However, this would be wrong if ParameterInstr is used to type
   // check the passed-in parameter, since the type check would then always be
   // wrongly eliminated.
   return Type::DynamicType();
 }
 
 
-intptr_t GraphEntryInstr::InputCount() const {
-  return 0;
-}
-
-
-Value* GraphEntryInstr::InputAt(intptr_t i) const {
-  UNREACHABLE();
-  return NULL;
-}
-
-
-void GraphEntryInstr::SetInputAt(intptr_t i, Value* value) {
-  UNREACHABLE();
-}
-
-
-intptr_t TargetEntryInstr::InputCount() const {
-  return 0;
-}
-
-
-Value* TargetEntryInstr::InputAt(intptr_t i) const {
-  UNREACHABLE();
-  return NULL;
-}
-
-
-void TargetEntryInstr::SetInputAt(intptr_t i, Value* value) {
-  UNREACHABLE();
-}
-
-
-intptr_t JoinEntryInstr::InputCount() const {
-  return 0;
-}
-
-
-Value* JoinEntryInstr::InputAt(intptr_t i) const {
-  UNREACHABLE();
-  return NULL;
-}
-
-
-void JoinEntryInstr::SetInputAt(intptr_t i, Value* value) {
-  UNREACHABLE();
-}
-
-
 intptr_t JoinEntryInstr::IndexOfPredecessor(BlockEntryInstr* pred) const {
   for (intptr_t i = 0; i < predecessors_.length(); ++i) {
     if (predecessors_[i] == pred) return i;
   }
   return -1;
 }
 
 
 // ==== Recording assigned variables.
 void Computation::RecordAssignedVars(BitVector* assigned_vars,
@@ skipping 925 matching lines @@
   if (compiler->is_ssa()) {
     ASSERT(locs()->in(0).IsRegister());
     __ PushRegister(locs()->in(0).reg());
   }
 }
 
 
 #undef __
 
 }  // namespace dart