[deoptimizer] Support float registers and slots.

src/deoptimizer.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_DEOPTIMIZER_H_
 #define V8_DEOPTIMIZER_H_
 
 #include "src/allocation.h"
 #include "src/macro-assembler.h"
 
@@ skipping 21 matching lines @@
  private:
   friend class TranslatedState;
   friend class TranslatedFrame;
 
   enum Kind {
     kInvalid,
     kTagged,
     kInt32,
     kUInt32,
     kBoolBit,
+    kFloat,
     kDouble,
     kCapturedObject,    // Object captured by the escape analysis.
                         // The number of nested objects can be obtained
                         // with the DeferredObjectLength() method
                         // (the values of the nested objects follow
                         // this value in the depth-first order.)
     kDuplicatedObject,  // Duplicated object of a deferred object.
     kArgumentsObject    // Arguments object - only used to keep indexing
                         // in sync, it should not be materialized.
   };
 
   TranslatedValue(TranslatedState* container, Kind kind)
       : kind_(kind), container_(container) {}
   Kind kind() const { return kind_; }
   void Handlify();
   int GetChildrenCount() const;
 
   static TranslatedValue NewArgumentsObject(TranslatedState* container,
                                             int length, int object_index);
   static TranslatedValue NewDeferredObject(TranslatedState* container,
                                            int length, int object_index);
   static TranslatedValue NewDuplicateObject(TranslatedState* container, int id);
+  static TranslatedValue NewFloat(TranslatedState* container, float value);
   static TranslatedValue NewDouble(TranslatedState* container, double value);
   static TranslatedValue NewInt32(TranslatedState* container, int32_t value);
   static TranslatedValue NewUInt32(TranslatedState* container, uint32_t value);
   static TranslatedValue NewBool(TranslatedState* container, uint32_t value);
   static TranslatedValue NewTagged(TranslatedState* container, Object* literal);
   static TranslatedValue NewInvalid(TranslatedState* container);
 
   Isolate* isolate() const;
   void MaterializeSimple();
 
@@ skipping 12 matching lines @@
     int length_;  // Applies only to kArgumentsObject or kCapturedObject kinds.
   };
 
   union {
     // kind kTagged. After handlification it is always nullptr.
     Object* raw_literal_;
     // kind is kUInt32 or kBoolBit.
     uint32_t uint32_value_;
     // kind is kInt32.
     int32_t int32_value_;
+    // kind is kFloat
+    float float_value_;
     // kind is kDouble
     double double_value_;
     // kind is kDuplicatedObject or kArgumentsObject or kCapturedObject.
     MaterializedObjectInfo materialization_info_;
   };
 
   // Checked accessors for the union members.
   Object* raw_literal() const;
   int32_t int32_value() const;
   uint32_t uint32_value() const;
+  float float_value() const;
   double double_value() const;
   int object_length() const;
   int object_index() const;
 };
 
 
 class TranslatedFrame {
  public:
   enum Kind {
     kFunction,
@@ skipping 615 matching lines @@
     // improperly detects an array bounds overflow in optimized debug builds
     // when using a plain DCHECK.
     if (n >= arraysize(registers_)) {
       DCHECK(false);
       return 0;
     }
 #endif
     return registers_[n];
   }
 
+  float GetFloatRegister(unsigned n) const {
+    DCHECK(n < arraysize(float_registers_));
+    return float_registers_[n];
+  }
+
   double GetDoubleRegister(unsigned n) const {
     DCHECK(n < arraysize(double_registers_));
     return double_registers_[n];
   }
 
   void SetRegister(unsigned n, intptr_t value) {
     DCHECK(n < arraysize(registers_));
     registers_[n] = value;
   }
 
+  void SetFloatRegister(unsigned n, float value) {
+    DCHECK(n < arraysize(float_registers_));
+    float_registers_[n] = value;
+  }
+
   void SetDoubleRegister(unsigned n, double value) {
     DCHECK(n < arraysize(double_registers_));
     double_registers_[n] = value;
   }
 
   intptr_t registers_[Register::kNumRegisters];
+  float float_registers_[FloatRegister::kMaxNumRegisters];
   double double_registers_[DoubleRegister::kMaxNumRegisters];
 };
 
 
 class FrameDescription {
  public:
   explicit FrameDescription(uint32_t frame_size, int parameter_count = 0);
 
   void* operator new(size_t size, uint32_t frame_size) {
     // Subtracts kPointerSize, as the member frame_content_ already supplies
@@ skipping 203 matching lines @@
   V(ARGUMENTS_ADAPTOR_FRAME)       \
   V(TAIL_CALLER_FRAME)             \
   V(COMPILED_STUB_FRAME)           \
   V(DUPLICATED_OBJECT)             \
   V(ARGUMENTS_OBJECT)              \
   V(CAPTURED_OBJECT)               \
   V(REGISTER)                      \
   V(INT32_REGISTER)                \
   V(UINT32_REGISTER)               \
   V(BOOL_REGISTER)                 \
+  V(FLOAT_REGISTER)                \
   V(DOUBLE_REGISTER)               \
   V(STACK_SLOT)                    \
   V(INT32_STACK_SLOT)              \
   V(UINT32_STACK_SLOT)             \
   V(BOOL_STACK_SLOT)               \
+  V(FLOAT_STACK_SLOT)              \
   V(DOUBLE_STACK_SLOT)             \
   V(LITERAL)
 
 class Translation BASE_EMBEDDED {
  public:
 #define DECLARE_TRANSLATION_OPCODE_ENUM(item) item,
   enum Opcode {
     TRANSLATION_OPCODE_LIST(DECLARE_TRANSLATION_OPCODE_ENUM)
     LAST = LITERAL
   };
@@ skipping 21 matching lines @@
   void BeginConstructStubFrame(int literal_id, unsigned height);
   void BeginGetterStubFrame(int literal_id);
   void BeginSetterStubFrame(int literal_id);
   void BeginArgumentsObject(int args_length);
   void BeginCapturedObject(int length);
   void DuplicateObject(int object_index);
   void StoreRegister(Register reg);
   void StoreInt32Register(Register reg);
   void StoreUint32Register(Register reg);
   void StoreBoolRegister(Register reg);
+  void StoreFloatRegister(FloatRegister reg);
   void StoreDoubleRegister(DoubleRegister reg);
   void StoreStackSlot(int index);
   void StoreInt32StackSlot(int index);
   void StoreUint32StackSlot(int index);
   void StoreBoolStackSlot(int index);
+  void StoreFloatStackSlot(int index);
   void StoreDoubleStackSlot(int index);
   void StoreLiteral(int literal_id);
   void StoreArgumentsObject(bool args_known, int args_index, int args_length);
   void StoreJSFrameFunction();
 
   Zone* zone() const { return zone_; }
 
   static int NumberOfOperandsFor(Opcode opcode);
 
 #if defined(OBJECT_PRINT) || defined(ENABLE_DISASSEMBLER)
@@ skipping 93 matching lines @@
   std::vector<Handle<Object> > expression_stack_;
   int source_position_;
 
   friend class Deoptimizer;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_DEOPTIMIZER_H_