Experimental implementation: Exposing SIMD instructions into JavaScript

src/lithium.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 17 matching lines @@
 #ifndef V8_LITHIUM_H_
 #define V8_LITHIUM_H_
 
 #include "allocation.h"
 #include "hydrogen.h"
 #include "safepoint-table.h"
 
 namespace v8 {
 namespace internal {
 
-#define LITHIUM_OPERAND_LIST(V)         \
-  V(ConstantOperand, CONSTANT_OPERAND)  \
-  V(StackSlot,       STACK_SLOT)        \
-  V(DoubleStackSlot, DOUBLE_STACK_SLOT) \
-  V(Register,        REGISTER)          \
-  V(DoubleRegister,  DOUBLE_REGISTER)
+#define LITHIUM_OPERAND_LIST(V)               \
+  V(ConstantOperand,    CONSTANT_OPERAND)     \
+  V(StackSlot,          STACK_SLOT)           \
+  V(DoubleStackSlot,    DOUBLE_STACK_SLOT)    \
+  V(Float32x4StackSlot, FLOAT32x4_STACK_SLOT) \
+  V(Int32x4StackSlot,  INT32x4_STACK_SLOT)  \
+  V(Register,           REGISTER)             \
+  V(DoubleRegister,     DOUBLE_REGISTER)      \
+  V(Float32x4Register,  FLOAT32x4_REGISTER)   \
+  V(Int32x4Register,   INT32x4_REGISTER)
 
 
 class LOperand : public ZoneObject {
  public:
   enum Kind {
     INVALID,
     UNALLOCATED,
     CONSTANT_OPERAND,
     STACK_SLOT,
     DOUBLE_STACK_SLOT,
+    FLOAT32x4_STACK_SLOT,
+    INT32x4_STACK_SLOT,
     REGISTER,
     DOUBLE_REGISTER,
+    FLOAT32x4_REGISTER,
+    INT32x4_REGISTER,
     ARGUMENT
   };
 
   LOperand() : value_(KindField::encode(INVALID)) { }
 
   Kind kind() const { return KindField::decode(value_); }
   int index() const { return static_cast<int>(value_) >> kKindFieldWidth; }
 #define LITHIUM_OPERAND_PREDICATE(name, type) \
   bool Is##name() const { return kind() == type; }
   LITHIUM_OPERAND_LIST(LITHIUM_OPERAND_PREDICATE)
   LITHIUM_OPERAND_PREDICATE(Argument, ARGUMENT)
   LITHIUM_OPERAND_PREDICATE(Unallocated, UNALLOCATED)
   LITHIUM_OPERAND_PREDICATE(Ignored, INVALID)
 #undef LITHIUM_OPERAND_PREDICATE
-  bool Equals(LOperand* other) const { return value_ == other->value_; }
+  bool IsXMMRegister() const {
+    return kind() == FLOAT32x4_REGISTER || kind() == INT32x4_REGISTER;
+  }
+  bool IsXMMStackSlot() const {
+    return kind() == FLOAT32x4_STACK_SLOT || kind() == INT32x4_STACK_SLOT;
+  }
+  bool Equals(LOperand* other) const {
+    return value_ == other->value_ || (index() == other->index() &&
+        ((IsXMMRegister() && other->IsXMMRegister()) ||
+         (IsXMMStackSlot() && other->IsXMMStackSlot())));
+  }
 
   void PrintTo(StringStream* stream);
   void ConvertTo(Kind kind, int index) {
     value_ = KindField::encode(kind);
     value_ |= index << kKindFieldWidth;
     ASSERT(this->index() == index);
   }
 
   // Calls SetUpCache()/TearDownCache() for each subclass.
   static void SetUpCaches();
   static void TearDownCaches();
 
  protected:
-  static const int kKindFieldWidth = 3;
+  static const int kKindFieldWidth = 4;
   class KindField : public BitField<Kind, 0, kKindFieldWidth> { };
 
   LOperand(Kind kind, int index) { ConvertTo(kind, index); }
 
   unsigned value_;
 };
 
 
 class LUnallocated : public LOperand {
  public:
@@ skipping 63 matching lines @@
   static LUnallocated* cast(LOperand* op) {
     ASSERT(op->IsUnallocated());
     return reinterpret_cast<LUnallocated*>(op);
   }
 
   // The encoding used for LUnallocated operands depends on the policy that is
   // stored within the operand. The FIXED_SLOT policy uses a compact encoding
   // because it accommodates a larger pay-load.
   //
   // For FIXED_SLOT policy:
-  //     +------------------------------------------+
-  //     |       slot_index      |  vreg  | 0 | 001 |
-  //     +------------------------------------------+
+  //     +-------------------------------------------+
+  //     |       slot_index      |  vreg  | 0 | 0001 |
+  //     +-------------------------------------------+
   //
   // For all other (extended) policies:
-  //     +------------------------------------------+
-  //     |  reg_index  | L | PPP |  vreg  | 1 | 001 |    L ... Lifetime
-  //     +------------------------------------------+    P ... Policy
+  //     +-------------------------------------------+
+  //     |  reg_index  | L | PPP |  vreg  | 1 | 0001 |    L ... Lifetime
+  //     +-------------------------------------------+    P ... Policy
   //
   // The slot index is a signed value which requires us to decode it manually
   // instead of using the BitField utility class.
 
   // The superclass has a KindField.
-  STATIC_ASSERT(kKindFieldWidth == 3);
+  STATIC_ASSERT(kKindFieldWidth == 4);
 
   // BitFields for all unallocated operands.
-  class BasicPolicyField     : public BitField<BasicPolicy,     3,  1> {};
-  class VirtualRegisterField : public BitField<unsigned,        4, 18> {};
+  class BasicPolicyField     : public BitField<BasicPolicy,     4,  1> {};
+  class VirtualRegisterField : public BitField<unsigned,        5, 18> {};
 
   // BitFields specific to BasicPolicy::FIXED_SLOT.
-  class FixedSlotIndexField  : public BitField<int,            22, 10> {};
+  class FixedSlotIndexField  : public BitField<int,            23,  9> {};
 
   // BitFields specific to BasicPolicy::EXTENDED_POLICY.
-  class ExtendedPolicyField  : public BitField<ExtendedPolicy, 22,  3> {};
-  class LifetimeField        : public BitField<Lifetime,       25,  1> {};
-  class FixedRegisterField   : public BitField<int,            26,  6> {};
+  class ExtendedPolicyField  : public BitField<ExtendedPolicy, 23,  3> {};
+  class LifetimeField        : public BitField<Lifetime,       26,  1> {};
+  class FixedRegisterField   : public BitField<int,            27,  5> {};
 
   static const int kMaxVirtualRegisters = VirtualRegisterField::kMax + 1;
   static const int kFixedSlotIndexWidth = FixedSlotIndexField::kSize;
   static const int kMaxFixedSlotIndex = (1 << (kFixedSlotIndexWidth - 1)) - 1;
   static const int kMinFixedSlotIndex = -(1 << (kFixedSlotIndexWidth - 1));
 
   // Predicates for the operand policy.
   bool HasAnyPolicy() const {
     return basic_policy() == EXTENDED_POLICY &&
         extended_policy() == ANY;
@@ skipping 192 matching lines @@
 
  private:
   static const int kNumCachedOperands = 128;
   static LDoubleStackSlot* cache;
 
   LDoubleStackSlot() : LOperand() { }
   explicit LDoubleStackSlot(int index) : LOperand(DOUBLE_STACK_SLOT, index) { }
 };
 
 
+class LFloat32x4StackSlot V8_FINAL : public LOperand {
+ public:
+  static LFloat32x4StackSlot* Create(int index, Zone* zone) {
+    ASSERT(index >= 0);
+    if (index < kNumCachedOperands) return &cache[index];
+    return new(zone) LFloat32x4StackSlot(index);
+  }
+
+  static LFloat32x4StackSlot* cast(LOperand* op) {
+    ASSERT(op->IsStackSlot());
+    return reinterpret_cast<LFloat32x4StackSlot*>(op);
+  }
+
+  static void SetUpCache();
+  static void TearDownCache();
+
+ private:
+  static const int kNumCachedOperands = 128;
+  static LFloat32x4StackSlot* cache;
+
+  LFloat32x4StackSlot() : LOperand() { }
+  explicit LFloat32x4StackSlot(int index)
+      : LOperand(FLOAT32x4_STACK_SLOT, index) { }
+};
+
+
+class LInt32x4StackSlot V8_FINAL : public LOperand {
+ public:
+  static LInt32x4StackSlot* Create(int index, Zone* zone) {
+    ASSERT(index >= 0);
+    if (index < kNumCachedOperands) return &cache[index];
+    return new(zone) LInt32x4StackSlot(index);
+  }
+
+  static LInt32x4StackSlot* cast(LOperand* op) {
+    ASSERT(op->IsStackSlot());
+    return reinterpret_cast<LInt32x4StackSlot*>(op);
+  }
+
+  static void SetUpCache();
+  static void TearDownCache();
+
+ private:
+  static const int kNumCachedOperands = 128;
+  static LInt32x4StackSlot* cache;
+
+  LInt32x4StackSlot() : LOperand() { }
+  explicit LInt32x4StackSlot(int index)
+      : LOperand(INT32x4_STACK_SLOT, index) { }
+};
+
+
 class LRegister V8_FINAL : public LOperand {
  public:
   static LRegister* Create(int index, Zone* zone) {
     ASSERT(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
     return new(zone) LRegister(index);
   }
 
   static LRegister* cast(LOperand* op) {
     ASSERT(op->IsRegister());
@@ skipping 30 matching lines @@
 
  private:
   static const int kNumCachedOperands = 16;
   static LDoubleRegister* cache;
 
   LDoubleRegister() : LOperand() { }
   explicit LDoubleRegister(int index) : LOperand(DOUBLE_REGISTER, index) { }
 };
 
 
+class LFloat32x4Register V8_FINAL : public LOperand {
+ public:
+  static LFloat32x4Register* Create(int index, Zone* zone) {
+    ASSERT(index >= 0);
+    if (index < kNumCachedOperands) return &cache[index];
+    return new(zone) LFloat32x4Register(index);
+  }
+
+  static LFloat32x4Register* cast(LOperand* op) {
+    ASSERT(op->IsFloat32x4Register());
+    return reinterpret_cast<LFloat32x4Register*>(op);
+  }
+
+  static void SetUpCache();
+  static void TearDownCache();
+
+ private:
+  static const int kNumCachedOperands = 16;
+  static LFloat32x4Register* cache;
+
+  LFloat32x4Register() : LOperand() { }
+  explicit LFloat32x4Register(int index)
+      : LOperand(FLOAT32x4_REGISTER, index) { }
+};
+
+
+class LInt32x4Register V8_FINAL : public LOperand {
+ public:
+  static LInt32x4Register* Create(int index, Zone* zone) {
+    ASSERT(index >= 0);
+    if (index < kNumCachedOperands) return &cache[index];
+    return new(zone) LInt32x4Register(index);
+  }
+
+  static LInt32x4Register* cast(LOperand* op) {
+    ASSERT(op->IsInt32x4Register());
+    return reinterpret_cast<LInt32x4Register*>(op);
+  }
+
+  static void SetUpCache();
+  static void TearDownCache();
+
+ private:
+  static const int kNumCachedOperands = 16;
+  static LInt32x4Register* cache;
+
+  LInt32x4Register() : LOperand() { }
+  explicit LInt32x4Register(int index)
+      : LOperand(INT32x4_REGISTER, index) { }
+};
+
+
 class LParallelMove V8_FINAL : public ZoneObject {
  public:
   explicit LParallelMove(Zone* zone) : move_operands_(4, zone) { }
 
   void AddMove(LOperand* from, LOperand* to, Zone* zone) {
     move_operands_.Add(LMoveOperands(from, to), zone);
   }
 
   bool IsRedundant() const;
 
@@ skipping 343 matching lines @@
  private:
   LChunk* chunk_;
 
   DISALLOW_COPY_AND_ASSIGN(LPhase);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_LITHIUM_H_