[v8-dev] ARM: Make double registers low/high safe

src/arm/macro-assembler-arm.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 466 matching lines @@
                               const Condition cond = al);
   void VFPCompareAndLoadFlags(const DwVfpRegister src1,
                               const double src2,
                               const Register fpscr_flags,
                               const Condition cond = al);
 
   void Vmov(const DwVfpRegister dst,
             const double imm,
             const Register scratch = no_reg);
 
+  void VmovHigh(Register dst, DwVfpRegister src);
+  void VmovHigh(DwVfpRegister dst, Register src);
+  void VmovLow(Register dst, DwVfpRegister src);
+  void VmovLow(DwVfpRegister dst, Register src);
+
   // Converts the smi or heap number in object to an int32 using the rules
   // for ToInt32 as described in ECMAScript 9.5.: the value is truncated
   // and brought into the range -2^31 .. +2^31 - 1.
   void ConvertNumberToInt32(Register object,
                             Register dst,
                             Register heap_number_map,
                             Register scratch1,
                             Register scratch2,
                             Register scratch3,
                             DwVfpRegister double_scratch1,
-                            DwVfpRegister double_scratch2,
+                            LowDwVfpRegister double_scratch2,
                             Label* not_int32);
 
   // Loads the number from object into dst register.
   // If |object| is neither smi nor heap number, |not_number| is jumped to
   // with |object| still intact.
   void LoadNumber(Register object,
-                  DwVfpRegister dst,
+                  LowDwVfpRegister dst,
                   Register heap_number_map,
                   Register scratch,
                   Label* not_number);
 
   // Loads the number from object into double_dst in the double format.
   // Control will jump to not_int32 if the value cannot be exactly represented
   // by a 32-bit integer.
   // Floating point value in the 32-bit integer range that are not exact integer
   // won't be loaded.
   void LoadNumberAsInt32Double(Register object,
                                DwVfpRegister double_dst,
                                Register heap_number_map,
                                Register scratch,
-                               DwVfpRegister double_scratch,
+                               LowDwVfpRegister double_scratch,
                                Label* not_int32);
 
   // Loads the number from object into dst as a 32-bit integer.
   // Control will jump to not_int32 if the object cannot be exactly represented
   // by a 32-bit integer.
   // Floating point value in the 32-bit integer range that are not exact integer
   // won't be converted.
   void LoadNumberAsInt32(Register object,
                          Register dst,
                          Register heap_number_map,
                          Register scratch,
                          DwVfpRegister double_scratch0,
-                         DwVfpRegister double_scratch1,
+                         LowDwVfpRegister double_scratch1,
                          Label* not_int32);
 
 
   // Enter exit frame.
   // stack_space - extra stack space, used for alignment before call to C.
   void EnterExitFrame(bool save_doubles, int stack_space = 0);
 
   // Leave the current exit frame. Expects the return value in r0.
   // Expect the number of values, pushed prior to the exit frame, to
   // remove in a register (or no_reg, if there is nothing to remove).
@@ skipping 247 matching lines @@
   void AllocateHeapNumberWithValue(Register result,
                                    DwVfpRegister value,
                                    Register scratch1,
                                    Register scratch2,
                                    Register heap_number_map,
                                    Label* gc_required);
 
   // Copies a fixed number of fields of heap objects from src to dst.
   void CopyFields(Register dst,
                   Register src,
-                  DwVfpRegister double_scratch,
-                  SwVfpRegister single_scratch,
+                  LowDwVfpRegister double_scratch,
                   int field_count);
 
   // Copies a number of bytes from src to dst. All registers are clobbered. On
   // exit src and dst will point to the place just after where the last byte was
   // read or written and length will be zero.
   void CopyBytes(Register src,
                  Register dst,
                  Register length,
                  Register scratch);
 
@@ skipping 56 matching lines @@
                             Register scratch,
                             Label* fail);
 
   // Check to see if maybe_number can be stored as a double in
   // FastDoubleElements. If it can, store it at the index specified by key in
   // the FastDoubleElements array elements. Otherwise jump to fail.
   void StoreNumberToDoubleElements(Register value_reg,
                                    Register key_reg,
                                    Register elements_reg,
                                    Register scratch1,
+                                   LowDwVfpRegister double_scratch0,

[ulan, 2013/07/25 11:49:54]

double_scratch would be more consistent with the rest of code.

                                    Label* fail,
                                    int elements_offset = 0);
 
   // Compare an object's map with the specified map and its transitioned
   // elements maps if mode is ALLOW_ELEMENT_TRANSITION_MAPS. Condition flags are
   // set with result of map compare. If multiple map compares are required, the
   // compare sequences branches to early_success.
   void CompareMap(Register obj,
                   Register scratch,
                   Handle<Map> map,
@@ skipping 63 matching lines @@
   //   hash - holds the index's hash. Clobbered.
   //   index - holds the overwritten index on exit.
   void IndexFromHash(Register hash, Register index);
 
   // Get the number of least significant bits from a register
   void GetLeastBitsFromSmi(Register dst, Register src, int num_least_bits);
   void GetLeastBitsFromInt32(Register dst, Register src, int mun_least_bits);
 
   // Load the value of a smi object into a double register.
   // The register value must be between d0 and d15.
-  void SmiToDouble(DwVfpRegister value, Register smi);
+  void SmiToDouble(LowDwVfpRegister value, Register smi);
 
   // Check if a double can be exactly represented as a signed 32-bit integer.
   // Z flag set to one if true.
   void TestDoubleIsInt32(DwVfpRegister double_input,
-                         DwVfpRegister double_scratch);
+                         LowDwVfpRegister double_scratch);
 
   // Try to convert a double to a signed 32-bit integer.
   // Z flag set to one and result assigned if the conversion is exact.
   void TryDoubleToInt32Exact(Register result,
                              DwVfpRegister double_input,
-                             DwVfpRegister double_scratch);
+                             LowDwVfpRegister double_scratch);
 
   // Floor a double and writes the value to the result register.
   // Go to exact if the conversion is exact (to be able to test -0),
   // fall through calling code if an overflow occurred, else go to done.
+  // In return, input_high is loaded with high bits of input.
   void TryInt32Floor(Register result,
                      DwVfpRegister double_input,
                      Register input_high,
-                     DwVfpRegister double_scratch,
+                     LowDwVfpRegister double_scratch,
                      Label* done,
                      Label* exact);
 
   // Performs a truncating conversion of a floating point number as used by
   // the JS bitwise operations. See ECMA-262 9.5: ToInt32.
   // Double_scratch must be between d0 and d15.
   // Exits with 'result' holding the answer and all other registers clobbered.
   void ECMAToInt32(Register result,
                    DwVfpRegister double_input,
                    Register scratch,
                    Register scratch_high,
                    Register scratch_low,
-                   DwVfpRegister double_scratch);
+                   LowDwVfpRegister double_scratch);
 
   // Check whether d16-d31 are available on the CPU. The result is given by the
   // Z condition flag: Z==0 if d16-d31 available, Z==1 otherwise.
   void CheckFor32DRegs(Register scratch);
 
   // Does a runtime check for 16/32 FP registers. Either way, pushes 32 double
   // values to location, saving [d0..(d15|d31)].
   void SaveFPRegs(Register location, Register scratch);
 
   // Does a runtime check for 16/32 FP registers. Either way, pops 32 double
@@ skipping 301 matching lines @@
   // Get the location of a relocated constant (its address in the constant pool)
   // from its load site.
   void GetRelocatedValueLocation(Register ldr_location,
                                  Register result);
 
 
   void ClampUint8(Register output_reg, Register input_reg);
 
   void ClampDoubleToUint8(Register result_reg,
                           DwVfpRegister input_reg,
-                          DwVfpRegister temp_double_reg);
+                          LowDwVfpRegister temp_double_reg);

[ulan, 2013/07/25 11:49:54]

double_scratch would be more consistent with the rest of code.

 
 
   void LoadInstanceDescriptors(Register map, Register descriptors);
   void EnumLength(Register dst, Register map);
   void NumberOfOwnDescriptors(Register dst, Register map);
 
   template<typename Field>
   void DecodeField(Register reg) {
     static const int shift = Field::kShift;
     static const int mask = (Field::kMask >> shift) << kSmiTagSize;
@@ skipping 125 matching lines @@
 #define __FILE_LINE__ __FILE__ ":" CODE_COVERAGE_TOSTRING(__LINE__)
 #define ACCESS_MASM(masm) masm->stop(__FILE_LINE__); masm->
 #else
 #define ACCESS_MASM(masm) masm->
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_MACRO_ASSEMBLER_ARM_H_