Experimental implementation: Exposing SIMD instructions into JavaScript

src/deoptimizer.cc

 // Copyright 2013 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 1766 matching lines @@
     if (trace_scope_ != NULL) {
       PrintF(trace_scope_->file(),
              "Materialized a new heap number %p [%e] in slot %p\n",
              reinterpret_cast<void*>(*num),
              d.value(),
              d.destination());
     }
     Memory::Object_at(d.destination()) = *num;
   }
 
+  // Materialize all float32x4 before looking at arguments because when the
+  // output frames are used to materialize arguments objects later on they need
+  // to already contain valid float32x4 values.
+  for (int i = 0; i < deferred_float32x4s_.length(); i++) {
+    Float32x4MaterializationDescriptor<Address> d = deferred_float32x4s_[i];
+    Handle<Object> float32x4 = isolate_->factory()->NewFloat32x4(d.value());
+    if (trace_scope_ != NULL) {
+      PrintF(trace_scope_->file(),
+             "Materialized a new float32x4 %p "
+             "[float32x4(%e, %e, %e, %e)] in slot %p\n",
+             reinterpret_cast<void*>(*float32x4),
+             d.value().storage[0], d.value().storage[1],
+             d.value().storage[2], d.value().storage[3],
+             d.destination());
+    }
+    Memory::Object_at(d.destination()) = *float32x4;
+  }
+
+  // Materialize all int32x4 before looking at arguments because when the
+  // output frames are used to materialize arguments objects later on they need
+  // to already contain valid int32x4 values.
+  for (int i = 0; i < deferred_int32x4s_.length(); i++) {
+    Int32x4MaterializationDescriptor<Address> d = deferred_int32x4s_[i];
+    Handle<Object> int32x4 = isolate_->factory()->NewInt32x4(d.value());
+    if (trace_scope_ != NULL) {
+      PrintF(trace_scope_->file(),
+             "Materialized a new int32x4 %p "
+             "[int32x4(%u, %u, %u, %u)] in slot %p\n",
+             reinterpret_cast<void*>(*int32x4),
+             d.value().storage[0], d.value().storage[1],
+             d.value().storage[2], d.value().storage[3],
+             d.destination());
+    }
+    Memory::Object_at(d.destination()) = *int32x4;
+  }
+
+
   // Materialize all heap numbers required for arguments/captured objects.
   for (int i = 0; i < deferred_objects_double_values_.length(); i++) {
     HeapNumberMaterializationDescriptor<int> d =
         deferred_objects_double_values_[i];
     Handle<Object> num = isolate_->factory()->NewNumber(d.value());
     if (trace_scope_ != NULL) {
       PrintF(trace_scope_->file(),
              "Materialized a new heap number %p [%e] for object at %d\n",
              reinterpret_cast<void*>(*num),
              d.value(),
              d.destination());
     }
     ASSERT(values.at(d.destination())->IsTheHole());
     values.Set(d.destination(), num);
   }
 
   // Play it safe and clear all object double values before we continue.
   deferred_objects_double_values_.Clear();
 
+  // Materialize all float32x4 values required for arguments/captured objects.
+  for (int i = 0; i < deferred_objects_float32x4_values_.length(); i++) {
+    Float32x4MaterializationDescriptor<int> d =
+        deferred_objects_float32x4_values_[i];
+    Handle<Object> float32x4 = isolate_->factory()->NewFloat32x4(d.value());
+    if (trace_scope_ != NULL) {
+      PrintF(trace_scope_->file(),
+             "Materialized a new float32x4 %p "
+             "[float32x4(%e, %e, %e, %e)] for object at %d\n",
+             reinterpret_cast<void*>(*float32x4),
+             d.value().storage[0], d.value().storage[1],
+             d.value().storage[2], d.value().storage[3],
+             d.destination());
+    }
+    ASSERT(values.at(d.destination())->IsTheHole());
+    values.Set(d.destination(), float32x4);
+  }
+
+  // Play it safe and clear all object float32x4 values before we continue.
+  deferred_objects_float32x4_values_.Clear();
+
+  // Materialize all int32x4 values required for arguments/captured objects.
+  for (int i = 0; i < deferred_objects_int32x4_values_.length(); i++) {
+    Int32x4MaterializationDescriptor<int> d =
+        deferred_objects_int32x4_values_[i];
+    Handle<Object> int32x4 = isolate_->factory()->NewInt32x4(d.value());
+    if (trace_scope_ != NULL) {
+      PrintF(trace_scope_->file(),
+             "Materialized a new int32x4 %p "
+             "[int32x4(%u, %u, %u, %u)] for object at %d\n",
+             reinterpret_cast<void*>(*int32x4),
+             d.value().storage[0], d.value().storage[1],
+             d.value().storage[2], d.value().storage[3],
+             d.destination());
+    }
+    ASSERT(values.at(d.destination())->IsTheHole());
+    values.Set(d.destination(), int32x4);
+  }
+
+  // Play it safe and clear all object int32x4 values before we continue.
+  deferred_objects_int32x4_values_.Clear();
+
   // Materialize arguments/captured objects.
   if (!deferred_objects_.is_empty()) {
     List<Handle<Object> > materialized_objects(deferred_objects_.length());
     materialized_objects_ = &materialized_objects;
     materialized_values_ = &values;
 
     while (materialization_object_index_ < deferred_objects_.length()) {
       int object_index = materialization_object_index_;
       ObjectMaterializationDescriptor descriptor =
           deferred_objects_.at(object_index);
@@ skipping 191 matching lines @@
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         PrintF(trace_scope_->file(),
                "%e ; %s\n", value,
                DoubleRegister::AllocationIndexToString(input_reg));
       }
       AddObjectDoubleValue(value);
       return;
     }
 
+    case Translation::FLOAT32x4_REGISTER: {
+      int input_reg = iterator->Next();
+      float32x4_value_t value = input_->GetFloat32x4Register(input_reg);
+      if (trace_scope_ != NULL) {
+        PrintF(trace_scope_->file(),
+               "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
+               reinterpret_cast<intptr_t>(object_slot),
+               field_index);
+        PrintF(trace_scope_->file(),
+               "float32x4(%e, %e, %e, %e) ; %s\n", value.storage[0],
+               value.storage[1], value.storage[2], value.storage[3],
+               Float32x4Register::AllocationIndexToString(input_reg));
+      }
+      AddObjectFloat32x4Value(value);
+      return;
+    }
+
+    case Translation::INT32x4_REGISTER: {
+      int input_reg = iterator->Next();
+      int32x4_value_t value = input_->GetInt32x4Register(input_reg);
+      if (trace_scope_ != NULL) {
+        PrintF(trace_scope_->file(),
+               "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
+               reinterpret_cast<intptr_t>(object_slot),
+               field_index);
+        PrintF(trace_scope_->file(),
+               "int32x4(%u, %u, %u, %u) ; %s\n", value.storage[0],
+               value.storage[1], value.storage[2], value.storage[3],
+               Int32x4Register::AllocationIndexToString(input_reg));
+      }
+      AddObjectInt32x4Value(value);
+      return;
+    }
+
     case Translation::STACK_SLOT: {
       int input_slot_index = iterator->Next();
       unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
       intptr_t input_value = input_->GetFrameSlot(input_offset);
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         PrintF(trace_scope_->file(),
@@ skipping 67 matching lines @@
                "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         PrintF(trace_scope_->file(),
                "%e ; [sp + %d]\n", value, input_offset);
       }
       AddObjectDoubleValue(value);
       return;
     }
 
+    case Translation::FLOAT32x4_STACK_SLOT: {
+      int input_slot_index = iterator->Next();
+      unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
+      float32x4_value_t value = input_->GetFloat32x4FrameSlot(input_offset);
+      if (trace_scope_ != NULL) {
+        PrintF(trace_scope_->file(),
+               "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
+               reinterpret_cast<intptr_t>(object_slot),
+               field_index);
+        PrintF(trace_scope_->file(),
+               "float32x4(%e, %e, %e, %e) ; [sp + %d]\n",
+               value.storage[0], value.storage[1], value.storage[2],
+               value.storage[3], input_offset);
+      }
+      AddObjectFloat32x4Value(value);
+      return;
+    }
+
+    case Translation::INT32x4_STACK_SLOT: {
+      int input_slot_index = iterator->Next();
+      unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
+      int32x4_value_t value = input_->GetInt32x4FrameSlot(input_offset);
+      if (trace_scope_ != NULL) {
+        PrintF(trace_scope_->file(),
+               "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
+               reinterpret_cast<intptr_t>(object_slot),
+               field_index);
+        PrintF(trace_scope_->file(),
+               "int32x4(%u, %u, %u, %u) ; [sp + %d]\n",
+               value.storage[0], value.storage[1], value.storage[2],
+               value.storage[3], input_offset);
+      }
+      AddObjectInt32x4Value(value);
+      return;
+    }
+
     case Translation::LITERAL: {
       Object* literal = ComputeLiteral(iterator->Next());
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         literal->ShortPrint(trace_scope_->file());
         PrintF(trace_scope_->file(),
                " ; literal\n");
@@ skipping 162 matching lines @@
                value,
                DoubleRegister::AllocationIndexToString(input_reg));
       }
       // We save the untagged value on the side and store a GC-safe
       // temporary placeholder in the frame.
       AddDoubleValue(output_[frame_index]->GetTop() + output_offset, value);
       output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
       return;
     }
 
+    case Translation::FLOAT32x4_REGISTER: {
+      int input_reg = iterator->Next();
+      float32x4_value_t value = input_->GetFloat32x4Register(input_reg);
+      if (trace_scope_ != NULL) {
+        PrintF(trace_scope_->file(),
+               "    0x%08" V8PRIxPTR ":"
+               " [top + %d] <- float32x4(%e, %e, %e, %e) ; %s\n",
+               output_[frame_index]->GetTop() + output_offset,
+               output_offset,
+               value.storage[0], value.storage[1],
+               value.storage[2], value.storage[3],
+               Float32x4Register::AllocationIndexToString(input_reg));
+      }
+      // We save the untagged value on the side and store a GC-safe
+      // temporary placeholder in the frame.
+      AddFloat32x4Value(output_[frame_index]->GetTop() + output_offset, value);
+      output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
+      return;
+    }
+
+    case Translation::INT32x4_REGISTER: {
+      int input_reg = iterator->Next();
+      int32x4_value_t value = input_->GetInt32x4Register(input_reg);
+      if (trace_scope_ != NULL) {
+        PrintF(trace_scope_->file(),
+               "    0x%08" V8PRIxPTR ":"
+               " [top + %d] <- int32x4(%u, %u, %u, %u) ; %s\n",
+               output_[frame_index]->GetTop() + output_offset,
+               output_offset,
+               value.storage[0], value.storage[1],
+               value.storage[2], value.storage[3],
+               Int32x4Register::AllocationIndexToString(input_reg));
+      }
+      // We save the untagged value on the side and store a GC-safe
+      // temporary placeholder in the frame.
+      AddInt32x4Value(output_[frame_index]->GetTop() + output_offset, value);
+      output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
+      return;
+    }
+
     case Translation::STACK_SLOT: {
       int input_slot_index = iterator->Next();
       unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
       intptr_t input_value = input_->GetFrameSlot(input_offset);
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "    0x%08" V8PRIxPTR ": ",
                output_[frame_index]->GetTop() + output_offset);
         PrintF(trace_scope_->file(),
                "[top + %d] <- 0x%08" V8PRIxPTR " ; [sp + %d] ",
@@ skipping 81 matching lines @@
                value,
                input_offset);
       }
       // We save the untagged value on the side and store a GC-safe
       // temporary placeholder in the frame.
       AddDoubleValue(output_[frame_index]->GetTop() + output_offset, value);
       output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
       return;
     }
 
+    case Translation::FLOAT32x4_STACK_SLOT: {
+      int input_slot_index = iterator->Next();
+      unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
+      float32x4_value_t value = input_->GetFloat32x4FrameSlot(input_offset);
+      if (trace_scope_ != NULL) {
+        PrintF(trace_scope_->file(),
+               "    0x%08" V8PRIxPTR ": "
+               "[top + %d] <- float32x4(%e, %e, %e, %e) ; [sp + %d]\n",
+               output_[frame_index]->GetTop() + output_offset,
+               output_offset,
+               value.storage[0], value.storage[1],
+               value.storage[2], value.storage[3],
+               input_offset);
+      }
+      // We save the untagged value on the side and store a GC-safe
+      // temporary placeholder in the frame.
+      AddFloat32x4Value(output_[frame_index]->GetTop() + output_offset, value);
+      output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
+      return;
+    }
+
+    case Translation::INT32x4_STACK_SLOT: {
+      int input_slot_index = iterator->Next();
+      unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
+      int32x4_value_t value = input_->GetInt32x4FrameSlot(input_offset);
+      if (trace_scope_ != NULL) {
+        PrintF(trace_scope_->file(),
+               "    0x%08" V8PRIxPTR ": "
+               "[top + %d] <- int32x4(%u, %u, %u, %u) ; [sp + %d]\n",
+               output_[frame_index]->GetTop() + output_offset,
+               output_offset,
+               value.storage[0], value.storage[1],
+               value.storage[2], value.storage[3],
+               input_offset);
+      }
+      // We save the untagged value on the side and store a GC-safe
+      // temporary placeholder in the frame.
+      AddInt32x4Value(output_[frame_index]->GetTop() + output_offset, value);
+      output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
+      return;
+    }
+
     case Translation::LITERAL: {
       Object* literal = ComputeLiteral(iterator->Next());
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "    0x%08" V8PRIxPTR ": [top + %d] <- ",
                output_[frame_index]->GetTop() + output_offset,
                output_offset);
         literal->ShortPrint(trace_scope_->file());
         PrintF(trace_scope_->file(), " ; literal\n");
       }
@@ skipping 128 matching lines @@
 
 
 void Deoptimizer::AddObjectDoubleValue(double value) {
   deferred_objects_tagged_values_.Add(isolate()->heap()->the_hole_value());
   HeapNumberMaterializationDescriptor<int> value_desc(
       deferred_objects_tagged_values_.length() - 1, value);
   deferred_objects_double_values_.Add(value_desc);
 }
 
 
+void Deoptimizer::AddObjectFloat32x4Value(float32x4_value_t value) {
+  deferred_objects_tagged_values_.Add(isolate()->heap()->the_hole_value());
+  Float32x4MaterializationDescriptor<int> value_desc(
+      deferred_objects_tagged_values_.length() - 1, value);
+  deferred_objects_float32x4_values_.Add(value_desc);
+}
+
+
+void Deoptimizer::AddObjectInt32x4Value(int32x4_value_t value) {
+  deferred_objects_tagged_values_.Add(isolate()->heap()->the_hole_value());
+  Int32x4MaterializationDescriptor<int> value_desc(
+      deferred_objects_tagged_values_.length() - 1, value);
+  deferred_objects_int32x4_values_.Add(value_desc);
+}
+
+
 void Deoptimizer::AddDoubleValue(intptr_t slot_address, double value) {
   HeapNumberMaterializationDescriptor<Address> value_desc(
       reinterpret_cast<Address>(slot_address), value);
   deferred_heap_numbers_.Add(value_desc);
 }
 
 
+void Deoptimizer::AddFloat32x4Value(intptr_t slot_address,
+                                    float32x4_value_t value) {
+  Float32x4MaterializationDescriptor<Address> value_desc(
+      reinterpret_cast<Address>(slot_address), value);
+  deferred_float32x4s_.Add(value_desc);
+}
+
+
+void Deoptimizer::AddInt32x4Value(intptr_t slot_address,
+                                    int32x4_value_t value) {
+  Int32x4MaterializationDescriptor<Address> value_desc(
+      reinterpret_cast<Address>(slot_address), value);
+  deferred_int32x4s_.Add(value_desc);
+}
+
+
 void Deoptimizer::EnsureCodeForDeoptimizationEntry(Isolate* isolate,
                                                    BailoutType type,
                                                    int max_entry_id) {
   // We cannot run this if the serializer is enabled because this will
   // cause us to emit relocation information for the external
   // references. This is fine because the deoptimizer's code section
   // isn't meant to be serialized at all.
   ASSERT(type == EAGER || type == SOFT || type == LAZY);
   DeoptimizerData* data = isolate->deoptimizer_data();
   int entry_count = data->deopt_entry_code_entries_[type];
@@ skipping 220 matching lines @@
   buffer_->Add(reg.code(), zone());
 }
 
 
 void Translation::StoreDoubleRegister(DoubleRegister reg) {
   buffer_->Add(DOUBLE_REGISTER, zone());
   buffer_->Add(DoubleRegister::ToAllocationIndex(reg), zone());
 }
 
 
+void Translation::StoreFloat32x4Register(Float32x4Register reg) {
+  buffer_->Add(FLOAT32x4_REGISTER, zone());
+  buffer_->Add(Float32x4Register::ToAllocationIndex(reg), zone());
+}
+
+
+void Translation::StoreInt32x4Register(Int32x4Register reg) {
+  buffer_->Add(INT32x4_REGISTER, zone());
+  buffer_->Add(Int32x4Register::ToAllocationIndex(reg), zone());
+}
+
+
 void Translation::StoreStackSlot(int index) {
   buffer_->Add(STACK_SLOT, zone());
   buffer_->Add(index, zone());
 }
 
 
 void Translation::StoreInt32StackSlot(int index) {
   buffer_->Add(INT32_STACK_SLOT, zone());
   buffer_->Add(index, zone());
 }
 
 
 void Translation::StoreUint32StackSlot(int index) {
   buffer_->Add(UINT32_STACK_SLOT, zone());
   buffer_->Add(index, zone());
 }
 
 
 void Translation::StoreDoubleStackSlot(int index) {
   buffer_->Add(DOUBLE_STACK_SLOT, zone());
   buffer_->Add(index, zone());
 }
 
 
+void Translation::StoreFloat32x4StackSlot(int index) {
+  buffer_->Add(FLOAT32x4_STACK_SLOT, zone());
+  buffer_->Add(index, zone());
+}
+
+
+void Translation::StoreInt32x4StackSlot(int index) {
+  buffer_->Add(INT32x4_STACK_SLOT, zone());
+  buffer_->Add(index, zone());
+}
+
+
 void Translation::StoreLiteral(int literal_id) {
   buffer_->Add(LITERAL, zone());
   buffer_->Add(literal_id, zone());
 }
 
 
 void Translation::StoreArgumentsObject(bool args_known,
                                        int args_index,
                                        int args_length) {
   buffer_->Add(ARGUMENTS_OBJECT, zone());
   buffer_->Add(args_known, zone());
   buffer_->Add(args_index, zone());
   buffer_->Add(args_length, zone());
 }
 
 
 int Translation::NumberOfOperandsFor(Opcode opcode) {
   switch (opcode) {
     case GETTER_STUB_FRAME:
     case SETTER_STUB_FRAME:
     case DUPLICATED_OBJECT:
     case ARGUMENTS_OBJECT:
     case CAPTURED_OBJECT:
     case REGISTER:
     case INT32_REGISTER:
     case UINT32_REGISTER:
     case DOUBLE_REGISTER:
+    case FLOAT32x4_REGISTER:
+    case INT32x4_REGISTER:
     case STACK_SLOT:
     case INT32_STACK_SLOT:
     case UINT32_STACK_SLOT:
     case DOUBLE_STACK_SLOT:
+    case FLOAT32x4_STACK_SLOT:
+    case INT32x4_STACK_SLOT:
     case LITERAL:
     case COMPILED_STUB_FRAME:
       return 1;
     case BEGIN:
     case ARGUMENTS_ADAPTOR_FRAME:
     case CONSTRUCT_STUB_FRAME:
       return 2;
     case JS_FRAME:
       return 3;
   }
@@ skipping 39 matching lines @@
     case Translation::DUPLICATED_OBJECT:
     case Translation::ARGUMENTS_OBJECT:
     case Translation::CAPTURED_OBJECT:
       // This can be only emitted for local slots not for argument slots.
       break;
 
     case Translation::REGISTER:
     case Translation::INT32_REGISTER:
     case Translation::UINT32_REGISTER:
     case Translation::DOUBLE_REGISTER:
+    case Translation::FLOAT32x4_REGISTER:
+    case Translation::INT32x4_REGISTER:
       // We are at safepoint which corresponds to call.  All registers are
       // saved by caller so there would be no live registers at this
       // point. Thus these translation commands should not be used.
       break;
 
     case Translation::STACK_SLOT: {
       int slot_index = iterator->Next();
       Address slot_addr = SlotAddress(frame, slot_index);
       return SlotRef(slot_addr, SlotRef::TAGGED);
     }
 
     case Translation::INT32_STACK_SLOT: {
       int slot_index = iterator->Next();
       Address slot_addr = SlotAddress(frame, slot_index);
       return SlotRef(slot_addr, SlotRef::INT32);
     }
 
     case Translation::UINT32_STACK_SLOT: {
       int slot_index = iterator->Next();
       Address slot_addr = SlotAddress(frame, slot_index);
       return SlotRef(slot_addr, SlotRef::UINT32);
     }
 
     case Translation::DOUBLE_STACK_SLOT: {
       int slot_index = iterator->Next();
       Address slot_addr = SlotAddress(frame, slot_index);
       return SlotRef(slot_addr, SlotRef::DOUBLE);
     }
 
+    case Translation::FLOAT32x4_STACK_SLOT: {
+      int slot_index = iterator->Next();
+      Address slot_addr = SlotAddress(frame, slot_index);
+      return SlotRef(slot_addr, SlotRef::FLOAT32x4);
+    }
+
+    case Translation::INT32x4_STACK_SLOT: {
+      int slot_index = iterator->Next();
+      Address slot_addr = SlotAddress(frame, slot_index);
+      return SlotRef(slot_addr, SlotRef::INT32x4);
+    }
+
     case Translation::LITERAL: {
       int literal_index = iterator->Next();
       return SlotRef(data->GetIsolate(),
                      data->LiteralArray()->get(literal_index));
     }
 
     case Translation::COMPILED_STUB_FRAME:
       UNREACHABLE();
       break;
   }
@@ skipping 119 matching lines @@
 
 void DeoptimizedFrameInfo::Iterate(ObjectVisitor* v) {
   v->VisitPointer(BitCast<Object**>(&function_));
   v->VisitPointers(parameters_, parameters_ + parameters_count_);
   v->VisitPointers(expression_stack_, expression_stack_ + expression_count_);
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal