Use corerct conversions for DataView accessors.

src/runtime.cc

 // 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 1198 matching lines @@
 DATA_VIEW_GETTER(Int8, int8_t, NumberFromInt32)
 DATA_VIEW_GETTER(Uint16, uint16_t, NumberFromUint32)
 DATA_VIEW_GETTER(Int16, int16_t, NumberFromInt32)
 DATA_VIEW_GETTER(Uint32, uint32_t, NumberFromUint32)
 DATA_VIEW_GETTER(Int32, int32_t, NumberFromInt32)
 DATA_VIEW_GETTER(Float32, float, NumberFromDouble)
 DATA_VIEW_GETTER(Float64, double, NumberFromDouble)
 
 #undef DATA_VIEW_GETTER
 
+
+template <typename T>
+static T DataViewValueConverter(double value);

[titzer, 2013/07/12 16:37:02]

Can we name this function verb-ly, such as "ConvertDoubleToDataView"?

[Dmitry Lomov (no reviews), 2013/07/12 18:22:45]

Done.
ConvertValueToDataView is not a good name - we convert value to T, not to
DataView.
I called it DataViewConvertValue (similar to DataViewGetValue and
DataViewSetValue)
On 2013/07/12 16:37:02, titzer wrote:

+
+
+template <>
+int8_t DataViewValueConverter<int8_t>(double value) {
+  return static_cast<int8_t>(DoubleToInt32(value));
+}
+
+
+template <>
+int16_t DataViewValueConverter<int16_t>(double value) {
+  return static_cast<int16_t>(DoubleToInt32(value));
+}
+
+
+template <>
+int32_t DataViewValueConverter<int32_t>(double value) {
+  return DoubleToInt32(value);
+}
+
+
+template <>
+uint8_t DataViewValueConverter<uint8_t>(double value) {
+  return static_cast<uint8_t>(DoubleToUint32(value));
+}
+
+
+template <>
+uint16_t DataViewValueConverter<uint16_t>(double value) {
+  return static_cast<uint16_t>(DoubleToUint32(value));
+}
+
+
+template <>
+uint32_t DataViewValueConverter<uint32_t>(double value) {
+  return DoubleToUint32(value);
+}
+
+
+template <>
+float DataViewValueConverter<float>(double value) {
+  return static_cast<float>(value);
+}
+
+
+template <>
+double DataViewValueConverter<double>(double value) {
+  return value;
+}
+
+
 #define DATA_VIEW_SETTER(TypeName, Type)                                      \
   RUNTIME_FUNCTION(MaybeObject*, Runtime_DataViewSet##TypeName) {             \
     HandleScope scope(isolate);                                               \
     ASSERT(args.length() == 4);                                               \
     CONVERT_ARG_HANDLE_CHECKED(JSDataView, holder, 0);                        \
     CONVERT_ARG_HANDLE_CHECKED(Object, offset, 1);                            \
     CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);                             \
     CONVERT_BOOLEAN_ARG_CHECKED(is_little_endian, 3);                         \
-    Type v = static_cast<Type>(value->Number());                              \
+    Type v = DataViewValueConverter<Type>(value->Number());                   \
     if (DataViewSetValue(                                                     \
           isolate, holder, offset, is_little_endian, v)) {                    \
       return isolate->heap()->undefined_value();                              \
     } else {                                                                  \
       return isolate->Throw(*isolate->factory()->NewRangeError(               \
           "invalid_data_view_accessor_offset",                                \
           HandleVector<Object>(NULL, 0)));                                    \
     }                                                                         \
   }
 
@@ skipping 12800 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal