Merge ConstantInstr -> UnboxDouble to UnboxedConstant. Reduces register usage and allows for variou…

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/bigint_operations.h"
 #include "vm/bit_vector.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 307 matching lines @@
 }
 
 
 bool ConstantInstr::AttributesEqual(Instruction* other) const {
   ConstantInstr* other_constant = other->AsConstant();
   ASSERT(other_constant != NULL);
   return (value().raw() == other_constant->value().raw());
 }
 
 
+UnboxedConstantInstr::UnboxedConstantInstr(const Object& value)
+    : ConstantInstr(value), constant_address_(NULL) {
+  // Only doubles supported for now.
+  ASSERT(value.IsDouble());
+  constant_address_ =
+      FlowGraphBuilder::FindDoubleConstant(Double::Cast(value).value());
+}
+
 // Returns true if the value represents a constant.
 bool Value::BindsToConstant() const {
   return definition()->IsConstant();
 }
 
 
 // Returns true if the value represents constant null.
 bool Value::BindsToConstantNull() const {
   ConstantInstr* constant = definition()->AsConstant();
   return (constant != NULL) && constant->value().IsNull();
@@ skipping 879 matching lines @@
   return Utils::IsPowerOfTwo(Utils::Abs(int_value));
 }
 
 
 static bool ToIntegerConstant(Value* value, intptr_t* result) {
   if (!value->BindsToConstant()) {
     if (value->definition()->IsUnboxDouble()) {
       return ToIntegerConstant(value->definition()->AsUnboxDouble()->value(),
                                result);
     }
-
     return false;
   }
 
   const Object& constant = value->BoundConstant();
   if (constant.IsDouble()) {
     const Double& double_constant = Double::Cast(constant);
     *result = static_cast<intptr_t>(double_constant.value());
     return (static_cast<double>(*result) == double_constant.value());
   } else if (constant.IsSmi()) {
     *result = Smi::Cast(constant).Value();
@@ skipping 356 matching lines @@
   UnboxDoubleInstr* defn = value()->definition()->AsUnboxDouble();
   if ((defn != NULL) && (defn->value()->Type()->ToCid() == kDoubleCid)) {
     return defn->value()->definition();
   }
 
   return this;
 }
 
 
 Definition* UnboxDoubleInstr::Canonicalize(FlowGraph* flow_graph) {
+  if (!HasUses()) return NULL;
   // Fold away UnboxDouble(BoxDouble(v)).
-  BoxDoubleInstr* defn = value()->definition()->AsBoxDouble();
-  return (defn != NULL) ? defn->value()->definition() : this;
+  BoxDoubleInstr* box_defn = value()->definition()->AsBoxDouble();
+  if (box_defn != NULL) {
+    return box_defn->value()->definition();
+  }
+
+  ConstantInstr* c = value()->definition()->AsConstant();
+  if ((c != NULL) && c->value().IsDouble()) {
+    UnboxedConstantInstr* uc = new UnboxedConstantInstr(c->value());
+    flow_graph->InsertBefore(this, uc, NULL, Definition::kValue);
+    return uc;
+  }
+
+  return this;
 }
 
 
 Definition* BoxFloat32x4Instr::Canonicalize(FlowGraph* flow_graph) {
   if (input_use_list() == NULL) {
     // Environments can accomodate any representation. No need to box.
     return value()->definition();
   }
 
   // Fold away BoxFloat32x4(UnboxFloat32x4(v)).
@@ skipping 1721 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart