Use ldexp instead of pow for more accuracy

src/conversions-inl.h

 // Copyright 2011 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 212 matching lines @@
     if (negative) {
       if (number == 0) return -0.0;
       number = -number;
     }
     return static_cast<double>(number);
   }
 
   ASSERT(number != 0);
   // The double could be constructed faster from number (mantissa), exponent
   // and sign. Assuming it's a rare case more simple code is used.
-  return static_cast<double>(negative ? -number : number) * pow(2.0, exponent);
+  return ldexp(static_cast<double>(negative ? -number : number), exponent);
 }
 
 
 template <class Iterator, class EndMark>
 double InternalStringToInt(UnicodeCache* unicode_cache,
                            Iterator current,
                            EndMark end,
                            int radix) {
   const bool allow_trailing_junk = true;
   const double empty_string_val = JunkStringValue();
@@ skipping 417 matching lines @@
   ASSERT(buffer_pos < kBufferSize);
   buffer[buffer_pos] = '\0';
 
   double converted = Strtod(Vector<const char>(buffer, buffer_pos), exponent);
   return negative ? -converted : converted;
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_CONVERSIONS_INL_H_