Unboxed load/store indexed of Float32x4

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 28 matching lines @@
   V(_ImmutableArray, get:length, ImmutableArrayLength, 433698233)              \
   V(_TypedList, get:length, TypedDataLength, 231908172)                        \
   V(_TypedList, _getInt8, ByteArrayBaseGetInt8, 380843687)                     \
   V(_TypedList, _getUint8, ByteArrayBaseGetUint8, 380843687)                   \
   V(_TypedList, _getInt16, ByteArrayBaseGetInt16, 380843687)                   \
   V(_TypedList, _getUint16, ByteArrayBaseGetUint16, 380843687)                 \
   V(_TypedList, _getInt32, ByteArrayBaseGetInt32, 380843687)                   \
   V(_TypedList, _getUint32, ByteArrayBaseGetUint32, 380843687)                 \
   V(_TypedList, _getFloat32, ByteArrayBaseGetFloat32, 979971573)               \
   V(_TypedList, _getFloat64, ByteArrayBaseGetFloat64, 979971573)               \
+  V(_TypedList, _getFloat32x4, ByteArrayBaseGetFloat32x4, 690339584)           \
   V(_TypedList, _setInt8, ByteArrayBaseSetInt8, 287047804)                     \
   V(_TypedList, _setUint8, ByteArrayBaseSetUint8, 287047804)                   \
   V(_TypedList, _setInt16, ByteArrayBaseSetInt16, 287047804)                   \
   V(_TypedList, _setUint16, ByteArrayBaseSetUint16, 287047804)                 \
   V(_TypedList, _setInt32, ByteArrayBaseSetInt32, 287047804)                   \
   V(_TypedList, _setUint32, ByteArrayBaseSetUint32, 287047804)                 \
   V(_TypedList, _setFloat32, ByteArrayBaseSetFloat32, 1032541114)              \
   V(_TypedList, _setFloat64, ByteArrayBaseSetFloat64, 1032541114)              \
+  V(_TypedList, _setFloat32x4, ByteArrayBaseSetFloat32x4, 1016704782)          \
   V(_GrowableObjectArray, get:length, GrowableArrayLength, 725548050)          \
   V(_GrowableObjectArray, get:_capacity, GrowableArrayCapacity, 725548050)     \
   V(_StringBase, get:length, StringBaseLength, 320803993)                      \
   V(_StringBase, get:isEmpty, StringBaseIsEmpty, 110632481)                    \
   V(_StringBase, codeUnitAt, StringBaseCodeUnitAt, 984449525)                  \
   V(_StringBase, [], StringBaseCharAt, 1062366987)                             \
   V(_IntegerImplementation, toDouble, IntegerToDouble, 927078825)              \
   V(_Double, toInt, DoubleToInteger, 362666636)                                \
   V(_Double, truncateToDouble, DoubleTruncate, 620870996)                      \
   V(_Double, roundToDouble, DoubleRound, 620870996)                            \
@@ skipping 409 matching lines @@
   M(CatchEntry)                                                                \
   M(BinarySmiOp)                                                               \
   M(UnarySmiOp)                                                                \
   M(CheckStackOverflow)                                                        \
   M(SmiToDouble)                                                               \
   M(DoubleToInteger)                                                           \
   M(DoubleToSmi)                                                               \
   M(DoubleToDouble)                                                            \
   M(CheckClass)                                                                \
   M(CheckSmi)                                                                  \
+  M(CheckNonSmi)                                                               \
   M(Constant)                                                                  \
   M(CheckEitherNonSmi)                                                         \
   M(BinaryDoubleOp)                                                            \
   M(MathSqrt)                                                                  \
   M(UnboxDouble)                                                               \
   M(BoxDouble)                                                                 \
+  M(BoxFloat32x4)                                                              \
+  M(UnboxFloat32x4)                                                            \
   M(UnboxInteger)                                                              \
   M(BoxInteger)                                                                \
   M(BinaryMintOp)                                                              \
   M(ShiftMintOp)                                                               \
   M(UnaryMintOp)                                                               \
   M(CheckArrayBound)                                                           \
   M(Constraint)                                                                \
   M(StringFromCharCode)                                                        \
   M(InvokeMathCFunction)                                                       \
   M(GuardField)                                                                \
@@ skipping 231 matching lines @@
   intptr_t GetDeoptId() const {
     return deopt_id_;
   }
 
  private:
   friend class Definition;  // Needed for InsertBefore, InsertAfter.
 
   // Classes that set deopt_id_.
   friend class UnboxIntegerInstr;
   friend class UnboxDoubleInstr;
+  friend class UnboxFloat32x4Instr;
   friend class BinaryDoubleOpInstr;
   friend class BinaryMintOpInstr;
   friend class BinarySmiOpInstr;
   friend class UnarySmiOpInstr;
   friend class ShiftMintOpInstr;
   friend class UnaryMintOpInstr;
   friend class MathSqrtInstr;
   friend class CheckClassInstr;
   friend class GuardFieldInstr;
   friend class CheckSmiInstr;
+  friend class CheckNonSmiInstr;
   friend class CheckArrayBoundInstr;
   friend class CheckEitherNonSmiInstr;
   friend class LICM;
   friend class DoubleToSmiInstr;
   friend class DoubleToDoubleInstr;
   friend class InvokeMathCFunctionInstr;
   friend class FlowGraphOptimizer;
   friend class LoadIndexedInstr;
   friend class StoreIndexedInstr;
   friend class StoreInstanceFieldInstr;
@@ skipping 2907 matching lines @@
 
   virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckEitherNonSmiInstr);
 };
 
 
 class BoxDoubleInstr : public TemplateDefinition<1> {
  public:
-  BoxDoubleInstr(Value* value, InstanceCallInstr* instance_call)
-      : token_pos_((instance_call != NULL) ? instance_call->token_pos() : 0) {
+  explicit BoxDoubleInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
-  intptr_t token_pos() const { return token_pos_; }
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   DECLARE_INSTRUCTION(BoxDouble)
   virtual CompileType ComputeType() const;
 
  private:
-  const intptr_t token_pos_;
+  DISALLOW_COPY_AND_ASSIGN(BoxDoubleInstr);
+};
 
-  DISALLOW_COPY_AND_ASSIGN(BoxDoubleInstr);
+
+class BoxFloat32x4Instr : public TemplateDefinition<1> {
+ public:
+  explicit BoxFloat32x4Instr(Value* value) {
+    SetInputAt(0, value);
+  }
+
+  Value* value() const { return inputs_[0]; }
+
+  virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
+  virtual bool AffectedBySideEffect() const { return false; }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
+
+  virtual Representation RequiredInputRepresentation(intptr_t idx) const {
+    ASSERT(idx == 0);
+    return kUnboxedFloat32x4;
+  }
+
+  DECLARE_INSTRUCTION(BoxFloat32x4)
+  virtual CompileType ComputeType() const;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(BoxFloat32x4Instr);
 };
 
 
 class BoxIntegerInstr : public TemplateDefinition<1> {
  public:
   explicit BoxIntegerInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
@@ skipping 42 matching lines @@
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   DECLARE_INSTRUCTION(UnboxDouble)
   virtual CompileType ComputeType() const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxDoubleInstr);
 };
 
 
+class UnboxFloat32x4Instr : public TemplateDefinition<1> {
+ public:
+  UnboxFloat32x4Instr(Value* value, intptr_t deopt_id) {
+    SetInputAt(0, value);
+    deopt_id_ = deopt_id;
+  }
+
+  Value* value() const { return inputs_[0]; }
+
+  virtual bool CanDeoptimize() const {
+    return (value()->Type()->ToCid() != kFloat32x4Cid);
+  }
+
+  virtual bool HasSideEffect() const { return false; }
+
+  virtual Representation representation() const {
+    return kUnboxedFloat32x4;
+  }
+
+  virtual bool AffectedBySideEffect() const { return false; }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
+
+  DECLARE_INSTRUCTION(UnboxFloat32x4)
+  virtual CompileType ComputeType() const;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(UnboxFloat32x4Instr);
+};
+
+
 class UnboxIntegerInstr : public TemplateDefinition<1> {
  public:
   UnboxIntegerInstr(Value* value, intptr_t deopt_id) {
     SetInputAt(0, value);
     deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
@@ skipping 650 matching lines @@
 
   virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
   Value* value() const { return inputs_[0]; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckSmiInstr);
 };
 
 
+class CheckNonSmiInstr : public TemplateInstruction<1> {
+ public:
+  CheckNonSmiInstr(Value* value, intptr_t original_deopt_id) {
+    ASSERT(original_deopt_id != Isolate::kNoDeoptId);
+    SetInputAt(0, value);
+    deopt_id_ = original_deopt_id;
+  }
+
+  DECLARE_INSTRUCTION(CheckNonSmi)
+
+  virtual intptr_t ArgumentCount() const { return 0; }
+
+  virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool HasSideEffect() const { return false; }
+
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
+
+  virtual bool AffectedBySideEffect() const { return false; }
+
+  virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
+
+  Value* value() const { return inputs_[0]; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CheckNonSmiInstr);
+};
+
+
 class CheckArrayBoundInstr : public TemplateInstruction<2> {
  public:
   CheckArrayBoundInstr(Value* length,
                        Value* index,
                        intptr_t array_type,
                        InstanceCallInstr* instance_call)
       : array_type_(array_type) {
     SetInputAt(0, length);
     SetInputAt(1, index);
     deopt_id_ = instance_call->deopt_id();
@@ skipping 247 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_