ARM: Implement DoDivI in the lithium code generator.

src/safepoint-table.h

 // Copyright 2010 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 55 matching lines @@
   int gap_code_size() const {
     ASSERT(is_valid());
     return GapCodeSizeField::decode(info_);
   }
 
   int argument_count() const {
     ASSERT(is_valid());
     return ArgumentsField::decode(info_);
   }
 
+  bool has_doubles() const {
+    ASSERT(is_valid());
+    return SaveDoublesField::decode(info_);
+  }
+
   uint8_t* bits() {
     ASSERT(is_valid());
     return bits_;
   }
 
   bool HasRegisters() const;
   bool HasRegisterAt(int reg_index) const;
 
   // Reserve 13 bits for the gap code size. On ARM a constant pool can be
   // emitted when generating the gap code. The size of the const pool is less
   // than what can be represented in 12 bits, so 13 bits gives room for having
   // instructions before potentially emitting a constant pool.
   static const int kGapCodeSizeBits = 13;
   static const int kArgumentsFieldBits = 3;
+  static const int kSaveDoublesFieldBits = 1;
   static const int kDeoptIndexBits =
-      32 - kGapCodeSizeBits - kArgumentsFieldBits;
+      32 - kGapCodeSizeBits - kArgumentsFieldBits - kSaveDoublesFieldBits;
   class GapCodeSizeField: public BitField<unsigned, 0, kGapCodeSizeBits> {};
   class DeoptimizationIndexField: public BitField<int,
                                                   kGapCodeSizeBits,
                                                   kDeoptIndexBits> {};  // NOLINT
   class ArgumentsField: public BitField<unsigned,
                                         kGapCodeSizeBits + kDeoptIndexBits,
                                         kArgumentsFieldBits> {};  // NOLINT
+  class SaveDoublesField: public BitField<bool,
+                                          kGapCodeSizeBits + kDeoptIndexBits +
+                                          kArgumentsFieldBits,
+                                          kSaveDoublesFieldBits> { }; // NOLINT
+
  private:
   unsigned info_;
   uint8_t* bits_;
 };
 
 
 class SafepointTable BASE_EMBEDDED {
  public:
   explicit SafepointTable(Code* code);
 
@@ skipping 93 matching lines @@
       int deoptimization_index = Safepoint::kNoDeoptimizationIndex);
 
   // Define a new safepoint with registers on the stack for the
   // current position in the body and take the number of arguments on
   // top of the registers into account.
   Safepoint DefineSafepointWithRegisters(
       Assembler* assembler,
       int arguments,
       int deoptimization_index = Safepoint::kNoDeoptimizationIndex);
 
+  // Define a new safepoint with all double registers and the normal
+  // registers on the stack for the current position in the body and
+  // take the number of arguments on top of the registers into account.
+  // TODO(1043) Rewrite the three SafepointTableBuilder::DefineSafepoint
+  // methods to one method that uses template arguments.
+  Safepoint DefineSafepointWithRegistersAndDoubles(
+      Assembler* assembler,
+      int arguments,
+      int deoptimization_index = Safepoint::kNoDeoptimizationIndex);
+
   // Update the last safepoint with the size of the code generated for the gap
   // following it.
   void SetPcAfterGap(int pc) {
     ASSERT(!deoptimization_info_.is_empty());
     int index = deoptimization_info_.length() - 1;
     deoptimization_info_[index].pc_after_gap = pc;
   }
 
   // Emit the safepoint table after the body. The number of bits per
   // entry must be enough to hold all the pointer indexes.
   void Emit(Assembler* assembler, int bits_per_entry);
 
  private:
   struct DeoptimizationInfo {
     unsigned pc;
     unsigned deoptimization_index;
     unsigned pc_after_gap;
     unsigned arguments;
+    bool has_doubles;
   };
 
   uint32_t EncodeExceptPC(const DeoptimizationInfo& info);
 
   ZoneList<DeoptimizationInfo> deoptimization_info_;
   ZoneList<ZoneList<int>*> indexes_;
   ZoneList<ZoneList<int>*> registers_;
 
   bool emitted_;
   unsigned offset_;
 
   DISALLOW_COPY_AND_ASSIGN(SafepointTableBuilder);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SAFEPOINT_TABLE_H_