case DOUBLE_STACK_SLOT:
stream->Add("[double_stack:%d]", index());
break;
+ case FLOAT32x4_STACK_SLOT:
+ stream->Add("[float32x4_stack:%d]", index());
+ break;
+ case INT32x4_STACK_SLOT:
+ stream->Add("[int32x4_stack:%d]", index());
+ break;
case REGISTER:
stream->Add("[%s|R]", Register::AllocationIndexToString(index()));
break;
case DOUBLE_REGISTER:
stream->Add("[%s|R]", DoubleRegister::AllocationIndexToString(index()));
break;
+ case FLOAT32x4_REGISTER:
+ stream->Add("[%s|R]",
+ SIMD128Register::AllocationIndexToString(index()));
+ break;
+ case INT32x4_REGISTER:
+ stream->Add("[%s|R]",
+ SIMD128Register::AllocationIndexToString(index()));
+ break;
case ARGUMENT:
stream->Add("[arg:%d]", index());
break;
}
}
-#define DEFINE_OPERAND_CACHE(name, type) \
- L##name* L##name::cache = NULL; \
- \
- void L##name::SetUpCache() { \
- if (cache) return; \
- cache = new L##name[kNumCachedOperands]; \
- for (int i = 0; i < kNumCachedOperands; i++) { \
- cache[i].ConvertTo(type, i); \
- } \
- } \
- \
- void L##name::TearDownCache() { \
- delete[] cache; \
+
+template<LOperand::Kind kOperandKind, int kNumCachedOperands>
+LSubKindOperand<kOperandKind, kNumCachedOperands>*
+LSubKindOperand<kOperandKind, kNumCachedOperands>::cache = NULL;
+
+
+template<LOperand::Kind kOperandKind, int kNumCachedOperands>
+void LSubKindOperand<kOperandKind, kNumCachedOperands>::SetUpCache() {
+ if (cache) return;
+ cache = new LSubKindOperand[kNumCachedOperands];
+ for (int i = 0; i < kNumCachedOperands; i++) {
+ cache[i].ConvertTo(kOperandKind, i);
}
+}
+
+
+template<LOperand::Kind kOperandKind, int kNumCachedOperands>
+void LSubKindOperand<kOperandKind, kNumCachedOperands>::TearDownCache() {
+ delete[] cache;
+}
-LITHIUM_OPERAND_LIST(DEFINE_OPERAND_CACHE)
-#undef DEFINE_OPERAND_CACHE
void LOperand::SetUpCaches() {
-#define LITHIUM_OPERAND_SETUP(name, type) L##name::SetUpCache();
+#define LITHIUM_OPERAND_SETUP(name, type, number) L##name::SetUpCache();
LITHIUM_OPERAND_LIST(LITHIUM_OPERAND_SETUP)
#undef LITHIUM_OPERAND_SETUP
}
void LOperand::TearDownCaches() {
-#define LITHIUM_OPERAND_TEARDOWN(name, type) L##name::TearDownCache();
+#define LITHIUM_OPERAND_TEARDOWN(name, type, number) L##name::TearDownCache();
LITHIUM_OPERAND_LIST(LITHIUM_OPERAND_TEARDOWN)
#undef LITHIUM_OPERAND_TEARDOWN
}
void LPointerMap::RecordPointer(LOperand* op, Zone* zone) {
// Do not record arguments as pointers.
if (op->IsStackSlot() && op->index() < 0) return;
- ASSERT(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
+ ASSERT(!op->IsDoubleRegister() && !op->IsDoubleStackSlot() &&
+ !op->IsFloat32x4Register() && !op->IsFloat32x4StackSlot() &&
+ !op->IsInt32x4Register() && !op->IsInt32x4StackSlot());
pointer_operands_.Add(op, zone);
}
void LPointerMap::RemovePointer(LOperand* op) {
// Do not record arguments as pointers.
if (op->IsStackSlot() && op->index() < 0) return;
- ASSERT(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
+ ASSERT(!op->IsDoubleRegister() && !op->IsDoubleStackSlot() &&
+ !op->IsFloat32x4Register() && !op->IsFloat32x4StackSlot() &&
+ !op->IsInt32x4Register() && !op->IsInt32x4StackSlot());
for (int i = 0; i < pointer_operands_.length(); ++i) {
if (pointer_operands_[i]->Equals(op)) {
pointer_operands_.Remove(i);
void LPointerMap::RecordUntagged(LOperand* op, Zone* zone) {
// Do not record arguments as pointers.
if (op->IsStackSlot() && op->index() < 0) return;
- ASSERT(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
+ ASSERT(!op->IsDoubleRegister() && !op->IsDoubleStackSlot() &&
+ !op->IsFloat32x4Register() && !op->IsFloat32x4StackSlot() &&
+ !op->IsInt32x4Register() && !op->IsInt32x4StackSlot());
untagged_operands_.Add(op, zone);
}
// We are building three lists here:
//
// 1. In the result->object_mapping_ list (added to by the
-// LEnvironment::Add*Object methods), we store the lengths (number
-// of fields) of the captured objects in depth-first traversal order, or
-// in case of duplicated objects, we store the index to the duplicate object
-// (with a tag to differentiate between captured and duplicated objects).
+// LEnvironment::Add*Object methods), we store the lengths (number
+// of fields) of the captured objects in depth-first traversal order, or
+// in case of duplicated objects, we store the index to the duplicate object
+// (with a tag to differentiate between captured and duplicated objects).
//
// 2. The object fields are stored in the result->values_ list
-// (added to by the LEnvironment.AddValue method) sequentially as lists
-// of fields with holes for nested objects (the holes will be expanded
-// later by LCodegen::AddToTranslation according to the
-// LEnvironment.object_mapping_ list).
+// (added to by the LEnvironment.AddValue method) sequentially as lists
+// of fields with holes for nested objects (the holes will be expanded
+// later by LCodegen::AddToTranslation according to the
+// LEnvironment.object_mapping_ list).
//
// 3. The auxiliary objects_to_materialize array stores the hydrogen values
// in the same order as result->object_mapping_ list. This is used