Add a smi-check instruction for arithmetic smi operations.

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"
@@ skipping 1031 matching lines @@
 RawAbstractType* SmiToDoubleComp::CompileType() const {
   return Type::DoubleInterface();
 }
 
 
 RawAbstractType* CheckClassComp::CompileType() const {
   return AbstractType::null();
 }
 
 
+RawAbstractType* CheckSmiComp::CompileType() const {
+  return AbstractType::null();
+}
+
+
+// Optimizations that eliminate or simplify individual computations.
+Definition* Computation::TryReplace(BindInstr* instr) const {
+  return instr;
+}
+
+
+Definition* StrictCompareComp::TryReplace(BindInstr* instr) const {
+  UseVal* left_use = left()->AsUse();
+  UseVal* right_use = right()->AsUse();
+  if ((right_use == NULL) || (left_use == NULL)) return instr;
+  if (!right_use->BindsToConstant()) return instr;
+  const Object& right_constant = right_use->BoundConstant();
+  Definition* left = left_use->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_use->ResultCid() == kBoolCid)) {
+    // Remove the constant from the graph.
+    BindInstr* right = right_use->definition()->AsBind();
+    if (right != NULL) {
+      right->set_use_list(NULL);
+      right->RemoveFromGraph();
+    }
+    // Return left subexpression as the replacement for this instruction.
+    return left;
+  }
+  return instr;
+}
+
+
+Definition* CheckSmiComp::TryReplace(BindInstr* instr) const {
+  return (value()->ResultCid() == kSmiCid) ?  NULL : instr;

[srdjan, 2012/08/22 15:56:51]

This is too early to eliminate all checks as FlowGraphOptimizer runs before the
type propagation (and type propagation needs to run after some nodes have been
replaced). You should have another check in CheckSmiComp::EmitNative.

Maybe we need another pass after type propagation that will eliminate all
checks?

[Florian Schneider, 2012/08/23 07:53:15]

Already done. TryReplace is called by the pass OptimizeComputations which is
invoked after FlowGraphTypePropagator.

+}
+
+
 // Shared code generation methods (EmitNativeCode, MakeLocationSummary, and
 // PrepareEntry). Only assembly code that can be shared across all architectures
 // can be used. Machine specific register allocation and code generation
 // is located in intermediate_language_<arch>.cc
 
-
-// True iff. the arguments to a call will be properly pushed and can
-// be popped after the call.
-template <typename T> static bool VerifyCallComputation(T* comp) {
-  // Argument values should be consecutive temps.
-  //
-  // TODO(kmillikin): implement stack height tracking so we can also assert
-  // they are on top of the stack.
-  intptr_t previous = -1;
-  for (int i = 0; i < comp->ArgumentCount(); ++i) {
-    Value* val = comp->ArgumentAt(i);
-    if (!val->IsUse()) return false;
-    intptr_t current = val->AsUse()->definition()->temp_index();
-    if (i != 0) {
-      if (current != (previous + 1)) return false;
-    }
-    previous = current;
-  }
-  return true;
-}
-
-
 #define __ compiler->assembler()->
 
 void GraphEntryInstr::PrepareEntry(FlowGraphCompiler* compiler) {
   // Nothing to do.
 }
 
 
 void JoinEntryInstr::PrepareEntry(FlowGraphCompiler* compiler) {
   __ Bind(compiler->GetBlockLabel(this));
   if (HasParallelMove()) {
@@ skipping 154 matching lines @@
   return summary;
 }
 
 
 void StoreContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Nothing to do.  Context register were loaded by register allocator.
   ASSERT(locs()->in(0).reg() == CTX);
 }
 
 
-Definition* StrictCompareComp::TryReplace(BindInstr* instr) {
-  UseVal* left_use = left()->AsUse();
-  UseVal* right_use = right()->AsUse();
-  if ((right_use == NULL) || (left_use == NULL)) return NULL;
-  if (!right_use->BindsToConstant()) return NULL;
-  const Object& right_constant = right_use->BoundConstant();
-  Definition* left = left_use->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_use->ResultCid() == kBoolCid)) {
-    // Remove the constant from the graph.
-    BindInstr* right = right_use->definition()->AsBind();
-    if (right != NULL) {
-      right->set_use_list(NULL);
-      right->RemoveFromGraph();
-    }
-    // Return left subexpression as the replacement for this instruction.
-    return left;
-  }
-  return NULL;
-}
-
-
 LocationSummary* StrictCompareComp::MakeLocationSummary() const {
   return LocationSummary::Make(2,
                                Location::SameAsFirstInput(),
                                LocationSummary::kNoCall);
 }
 
 
 void StrictCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
@@ skipping 235 matching lines @@
                          intptr_t fixed_parameter_count)
     : values_(definitions.length()),
       locations_(NULL),
       fixed_parameter_count_(fixed_parameter_count) {
   for (intptr_t i = 0; i < definitions.length(); ++i) {
     values_.Add(UseDefinition(definitions[i]));
   }
 }
 
 
+Environment* Environment::Copy() const {
+  Environment* copy = new Environment(values().length(),
+                                      fixed_parameter_count());
+  GrowableArray<Value*>* values_copy = copy->values_ptr();
+  for (intptr_t i = 0; i < values().length(); ++i) {
+    Value* val = values()[i];
+    values_copy->Add(val->IsUse()
+                     ? UseDefinition(values()[i]->AsUse()->definition())
+                     : val);
+  }
+  return copy;
+}
+
+
 #undef __
 
 }  // namespace dart