ARM: VFP cleanup now that VFP2 is the baseline.

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 477 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);
 
+  // Convert the smi or heap number in object to an int32 using the rules

[ulan, 2013/04/22 11:24:49]

"Converts"

[Rodolph Perfetta, 2013/04/22 21:30:33]

Done.

+  // 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,
+                            Label* not_int32);
+
+  // Loads the objects from |object| into floating point registers.
+  // The value ends up either in |dst|.

[ulan, 2013/04/22 11:24:49]

"Loads the number from object into dst register."

[Rodolph Perfetta, 2013/04/22 21:30:33]

Done.

+  // If |object| is neither smi nor heap number, |not_number| is jumped to
+  // with |object| still intact.
+  void LoadNumber(Register object,
+                  DwVfpRegister dst,
+                  Register heap_number_map,
+                  Register scratch,
+                  Label* not_number);
+
+  // Load the number from object into double_dst in the double format.

[ulan, 2013/04/22 11:24:49]

"Loads"

[Rodolph Perfetta, 2013/04/22 21:30:33]

Done.

+  // 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,
+                               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,
+                         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).
   void LeaveExitFrame(bool save_doubles, Register argument_count);
 
   // Get the actual activation frame alignment for target environment.
@@ skipping 316 matching lines @@
                                Label* fail);
 
   // Check if a map for a JSObject indicates that the object has fast smi only
   // elements.  Jump to the specified label if it does not.
   void CheckFastSmiElements(Register map,
                             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, in which
-  // case scratch2, scratch3 and scratch4 are unmodified.
+  // the FastDoubleElements array elements. Otherwise jump to fail.
   void StoreNumberToDoubleElements(Register value_reg,
                                    Register key_reg,
-                                   // All regs below here overwritten.
                                    Register elements_reg,
                                    Register scratch1,
-                                   Register scratch2,
-                                   Register scratch3,
-                                   Register scratch4,
                                    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 111 matching lines @@
   // 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.
   void TryInt32Floor(Register result,
                      DwVfpRegister double_input,
                      Register input_high,
                      DwVfpRegister double_scratch,
                      Label* done,
                      Label* exact);
 
-  // Performs a truncating conversion of a heap floating point number as used by
-  // the JS bitwise operations. See ECMA-262 9.5: ToInt32.
-  // Exits with 'result' holding the answer.
-  void ECMAConvertNumberToInt32(Register source,
-                                Register result,
-                                Register input_low,
-                                Register input_high,
-                                Register scratch,
-                                DwVfpRegister double_scratch1,
-                                DwVfpRegister double_scratch2);
-
   // 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,
-                   DwVfpRegister double_scratch,
                    Register scratch,
-                   Register input_high,
-                   Register input_low);
+                   Register scratch_high,
+                   Register scratch_low,
+                   DwVfpRegister 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);
 
 
   // ---------------------------------------------------------------------------
   // Runtime calls
 
   // Call a code stub.
@@ skipping 108 matching lines @@
   void DecrementCounter(StatsCounter* counter, int value,
                         Register scratch1, Register scratch2);
 
 
   // ---------------------------------------------------------------------------
   // Debugging
 
   // Calls Abort(msg) if the condition cond is not satisfied.
   // Use --debug_code to enable.
   void Assert(Condition cond, const char* msg);
-  void AssertRegisterIsRoot(Register reg, Heap::RootListIndex index);
   void AssertFastElements(Register elements);
 
   // Like Assert(), but always enabled.
   void Check(Condition cond, const char* msg);
 
   // Print a message to stdout and abort execution.
   void Abort(const char* msg);
 
   // Verify restrictions about code generated in stubs.
   void set_generating_stub(bool value) { generating_stub_ = value; }
@@ skipping 89 matching lines @@
   // Abort execution if argument is a smi, enabled via --debug-code.
   void AssertNotSmi(Register object);
   void AssertSmi(Register object);
 
   // Abort execution if argument is not a string, enabled via --debug-code.
   void AssertString(Register object);
 
   // Abort execution if argument is not a name, enabled via --debug-code.
   void AssertName(Register object);
 
-  // Abort execution if argument is not the root value with the given index,
+  // Abort execution if reg is not the root value with the given index,
   // enabled via --debug-code.
-  void AssertRootValue(Register src,
-                       Heap::RootListIndex root_value_index,
-                       const char* message);
+  void AssertIsRoot(Register reg, Heap::RootListIndex index);
 
   // ---------------------------------------------------------------------------
   // HeapNumber utilities
 
   void JumpIfNotHeapNumber(Register object,
                            Register heap_number_map,
                            Register scratch,
                            Label* on_not_heap_number);
 
   // ---------------------------------------------------------------------------
@@ skipping 110 matching lines @@
   // bitmap register points at the word with the mark bits and the mask
   // the position of the first bit.  Leaves addr_reg unchanged.
   inline void GetMarkBits(Register addr_reg,
                           Register bitmap_reg,
                           Register mask_reg);
 
   // Helper for throwing exceptions.  Compute a handler address and jump to
   // it.  See the implementation for register usage.
   void JumpToHandlerEntry();
 
-  // Helper for ECMAToInt32VFP and ECMAToInt32NoVFP.
-  // It is expected that 31 <= exponent <= 83, and scratch is exponent - 1.
-  void ECMAToInt32Tail(Register result,
-                       Register scratch,
-                       Register input_high,
-                       Register input_low,
-                       Label* out_of_range,
-                       Label* negate,
-                       Label* done);
-
   // Compute memory operands for safepoint stack slots.
   static int SafepointRegisterStackIndex(int reg_code);
   MemOperand SafepointRegisterSlot(Register reg);
   MemOperand SafepointRegistersAndDoublesSlot(Register reg);
 
   bool generating_stub_;
   bool allow_stub_calls_;
   bool has_frame_;
   // This handle will be patched with the code object on installation.
   Handle<Object> code_object_;
@@ skipping 53 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_