Support for multiple register values

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 761 matching lines @@
   M(UnboxFloat64x2)                                                            \
   M(BinaryFloat64x2Op)                                                         \
   M(Float64x2Zero)                                                             \
   M(Float64x2Constructor)                                                      \
   M(Float64x2Splat)                                                            \
   M(Float32x4ToFloat64x2)                                                      \
   M(Float64x2ToFloat32x4)                                                      \
   M(Simd64x2Shuffle)                                                           \
   M(Float64x2ZeroArg)                                                          \
   M(Float64x2OneArg)                                                           \
+  M(ExtractNthOutput)                                                          \
 
 
 #define FORWARD_DECLARATION(type) class type##Instr;
 FOR_EACH_INSTRUCTION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 
 // Functions required in all concrete instruction classes.
 #define DECLARE_INSTRUCTION(type)                                              \
   virtual Tag tag() const { return k##type; }                                  \
@@ skipping 965 matching lines @@
   void ClearTempIndex() { temp_index_ = -1; }
 
   intptr_t ssa_temp_index() const { return ssa_temp_index_; }
   void set_ssa_temp_index(intptr_t index) {
     ASSERT(index >= 0);
     ASSERT(is_used());
     ssa_temp_index_ = index;
   }
   bool HasSSATemp() const { return ssa_temp_index_ >= 0; }
   void ClearSSATempIndex() { ssa_temp_index_ = -1; }
-
+  bool HasPairRepresentation() const {
+    return (representation() == kPairOfTagged) ||
+           (representation() == kPairOfUnboxedDouble);
+  }
   bool is_used() const { return (use_kind_ != kEffect); }
   void set_use_kind(UseKind kind) { use_kind_ = kind; }
 
   // Compile time type of the definition, which may be requested before type
   // propagation during graph building.
   CompileType* Type() {
     if (type_ == NULL) {
       type_ = ComputeInitialType();
     }
     return type_;
@@ skipping 5501 matching lines @@
   }
 
   ZoneGrowableArray<Value*>* inputs_;
 
   const MethodRecognizer::Kind recognized_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(InvokeMathCFunctionInstr);
 };
 
 
+class ExtractNthOutputInstr : public TemplateDefinition<1> {
+ public:
+  // Extract the Nth output register from value.
+  ExtractNthOutputInstr(Value* value,
+                        intptr_t n,
+                        Representation definition_rep,
+                        intptr_t definition_cid)
+      : index_(n),
+        definition_rep_(definition_rep),
+        definition_cid_(definition_cid) {
+    SetInputAt(0, value);
+  }
+
+  Value* value() const { return inputs_[0]; }
+
+  DECLARE_INSTRUCTION(ExtractNthOutput)
+
+  virtual CompileType ComputeType() const;
+  virtual void PrintOperandsTo(BufferFormatter* f) const;
+  virtual bool CanDeoptimize() const { return false; }
+
+  intptr_t index() const { return index_; }
+
+  virtual Representation representation() const {
+    return definition_rep_;
+  }
+
+  virtual Representation RequiredInputRepresentation(intptr_t idx) const {
+    ASSERT(idx == 0);
+    if (representation() == kTagged) {
+      return kPairOfTagged;
+    } else if (representation() == kUnboxedDouble) {
+      return kPairOfUnboxedDouble;
+    }
+    UNREACHABLE();
+    return definition_rep_;
+  }
+
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const {
+    ExtractNthOutputInstr* other_extract = other->AsExtractNthOutput();
+    return (other_extract->representation() == representation()) &&
+           (other_extract->index() == index());
+  }
+
+  virtual bool MayThrow() const { return false; }
+
+ private:
+  const intptr_t index_;
+  const Representation definition_rep_;
+  const intptr_t definition_cid_;
+  DISALLOW_COPY_AND_ASSIGN(ExtractNthOutputInstr);
+};
+
+
 class MergedMathInstr : public Definition {
  public:
   enum Kind {
     kTruncDivMod,
-    kTruncDivRem,
     kSinCos,
   };
 
   MergedMathInstr(ZoneGrowableArray<Value*>* inputs,
                   intptr_t original_deopt_id,
                   MergedMathInstr::Kind kind);
 
   static intptr_t InputCountFor(MergedMathInstr::Kind kind) {
     if (kind == kTruncDivMod) {
       return 2;
     } else if (kind == kSinCos) {
       return 1;
     } else {
       UNIMPLEMENTED();
       return -1;
     }
   }
 
   MergedMathInstr::Kind kind() const { return kind_; }
 
   virtual intptr_t InputCount() const { return inputs_->length(); }
 
   virtual Value* InputAt(intptr_t i) const {
     return (*inputs_)[i];
   }
 
+  static intptr_t OutputIndexOf(intptr_t kind);
+  static intptr_t OutputIndexOf(Token::Kind token);
+
   virtual CompileType ComputeType() const;
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const {
     if (kind_ == kTruncDivMod) {
       return true;
     } else if (kind_ == kSinCos) {
       return false;
     } else {
       UNIMPLEMENTED();
       return false;
     }
   }
 
   virtual Representation representation() const {
     if (kind_ == kTruncDivMod) {
-      return kTagged;
+      return kPairOfTagged;
     } else if (kind_ == kSinCos) {
-      return kTagged;
+      return kPairOfUnboxedDouble;
     } else {
       UNIMPLEMENTED();
       return kTagged;
     }
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((0 <= idx) && (idx < InputCount()));
     if (kind_ == kTruncDivMod) {
       return kTagged;
     } else if (kind_ == kSinCos) {
       return kUnboxedDouble;
     } else {
       UNIMPLEMENTED();
       return kTagged;
     }
   }
 
   virtual intptr_t DeoptimizationTarget() const { return deopt_id_; }
 
-  // Returns the result index for one of the merged instructjons
-  static intptr_t ResultIndexOf(MethodRecognizer::Kind kind);
-  static intptr_t ResultIndexOf(Token::Kind token);
-
   DECLARE_INSTRUCTION(MergedMath)
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     MergedMathInstr* other_invoke = other->AsMergedMath();
     return other_invoke->kind() == kind();
   }
 
   virtual bool MayThrow() const { return false; }
 
   static const char* KindToCString(MergedMathInstr::Kind kind) {
     if (kind == kTruncDivMod) return "TruncDivMod";
     if (kind == kSinCos) return "SinCos";
     UNIMPLEMENTED();
     return "";
   }
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     (*inputs_)[i] = value;
   }
-
   ZoneGrowableArray<Value*>* inputs_;
   MergedMathInstr::Kind kind_;
-
   DISALLOW_COPY_AND_ASSIGN(MergedMathInstr);
 };
 
 
 class CheckClassInstr : public TemplateInstruction<1> {
  public:
   CheckClassInstr(Value* value,
                   intptr_t deopt_id,
                   const ICData& unary_checks);
 
@@ skipping 323 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_