Add support for XMM registers in SSA code generation pipeline.

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 170 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 BindInstr::InsertBefore(BindInstr* next) {
+void BindInstr::InsertBefore(Instruction* next) {
   ASSERT(previous_ == NULL);
   ASSERT(next_ == NULL);
   next_ = next;
   previous_ = next->previous_;
   next->previous_ = this;
   previous_->next_ = this;
 }
 
 
+void BindInstr::InsertAfter(Instruction* prev) {
+  ASSERT(previous_ == NULL);
+  ASSERT(next_ == NULL);
+  previous_ = prev;
+  next_ = prev->next_;
+  next_->previous_ = this;
+  previous_->next_ = this;
+}
+
+
 void ForwardInstructionIterator::RemoveCurrentFromGraph() {
   current_ = current_->RemoveFromGraph(true);  // Set current_ to previous.
 }
 
 
 // Default implementation of visiting basic blocks.  Can be overridden.
 void FlowGraphVisitor::VisitBlocks() {
   ASSERT(current_iterator_ == NULL);
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* entry = block_order_[i];
@@ skipping 806 matching lines @@
 RawAbstractType* BinaryDoubleOpComp::CompileType() const {
   return Type::DoubleInterface();
 }
 
 
 intptr_t BinaryDoubleOpComp::ResultCid() const {
   return kDoubleCid;
 }
 
 
+RawAbstractType* UnboxedDoubleBinaryOpComp::CompileType() const {
+  return Type::DoubleInterface();
+}
+
+
+RawAbstractType* UnboxDoubleComp::CompileType() const {
+  return Type::null();
+}
+
+
+intptr_t BoxDoubleComp::ResultCid() const {
+  return kDoubleCid;
+}
+
+
+RawAbstractType* BoxDoubleComp::CompileType() const {
+  return Type::DoubleInterface();
+}
+
+
 RawAbstractType* UnarySmiOpComp::CompileType() const {
   return Type::SmiType();
 }
 
 
 RawAbstractType* NumberNegateComp::CompileType() const {
   // Implemented only for doubles.
   return Type::DoubleInterface();
 }
 
@@ skipping 11 matching lines @@
 RawAbstractType* CheckClassComp::CompileType() const {
   return AbstractType::null();
 }
 
 
 RawAbstractType* CheckSmiComp::CompileType() const {
   return AbstractType::null();
 }
 
 
+RawAbstractType* CheckEitherNonSmiComp::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;
@@ skipping 15 matching lines @@
   }
   return instr;
 }
 
 
 Definition* CheckSmiComp::TryReplace(BindInstr* instr) const {
   return (value()->ResultCid() == kSmiCid) ?  NULL : instr;
 }
 
 
+Definition* CheckEitherNonSmiComp::TryReplace(BindInstr* instr) const {
+  if ((left()->ResultCid() == kDoubleCid) ||
+      (right()->ResultCid() == kDoubleCid)) {
+    return NULL;  // Remove from the graph.
+  }
+  return instr;
+}
+
+
 // 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
 
 #define __ compiler->assembler()->
 
 void GraphEntryInstr::PrepareEntry(FlowGraphCompiler* compiler) {
   // Nothing to do.
 }
@@ skipping 431 matching lines @@
                      ? UseDefinition(values()[i]->AsUse()->definition())
                      : val);
   }
   return copy;
 }
 
 
 #undef __
 
 }  // namespace dart