Changeset 29243 in webkit for trunk/JavaScriptCore/kjs/value.cpp

Timestamp:

Jan 7, 2008, 1:50:51 PM (17 years ago)

Author:

Darin Adler

Message:

Reviewed by David Kilzer.

• fix alignment problem with NaN and Inf globals

• kjs/fpconst.cpp: Move the contents of this file from here back to value.cpp. The reason this was in a separate file is that the DARWIN version of this used a declaration of the globals with a different type to avoid creating "init routines". That's no longer necessary for DARWIN and was never necessary for the non-DARWIN code path. To make this patch easy to merge, I didn't actually delete this file yet. We'll do that in a separate changeset.

• kjs/value.cpp: If C99's NAN and INFINITY are present, then use them, othrewise use the union trick from fpconst.cpp. I think it would be better to eliminate KJS::NaN and KJS::Inf and just use NAN and INFINITY directly or std::numeric_limits<double>::quiet_nan() and std::numeric_limits<double>::infinity(). But when I tried that, it slowed down SunSpider. Someone else could do that cleanup if they could do it without slowing down the engine.

File:

• trunk/JavaScriptCore/kjs/value.cpp (modified) (2 diffs)

trunk/JavaScriptCore/kjs/value.cpp

@@ -2 +2 @@
  *  Copyright (C) 1999-2001 Harri Porten ([email protected])
  *  Copyright (C) 2001 Peter Kelly ([email protected])
- *  Copyright (C) 2003, 2007 Apple Inc. All rights reserved.
+ *  Copyright (C) 2003, 2007, 2008 Apple Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
@@ -31 +31 @@
 
 namespace KJS {
+
+#if defined NAN && defined INFINITY
+
+extern const double NaN = NAN;
+extern const double Inf = INFINITY;
+
+#else // !(defined NAN && defined INFINITY)
+
+// The trick is to define the NaN and Inf globals with a different type than the declaration.
+// This trick works because the mangled name of the globals does not include the type, although
+// I'm not sure that's guaranteed. There could be alignment issues with this, since arrays of
+// characters don't necessarily need the same alignment doubles do, but for now it seems to work.
+// It would be good to figure out a 100% clean way that still avoids code that runs at init time.
+
+// Note, we have to use union to ensure alignment. Otherwise, NaN_Bytes can start anywhere,
+// while NaN_double has to be 4-byte aligned for 32-bits.
+// With -fstrict-aliasing enabled, unions are the only safe way to do type masquerading.
+
+static const union {
+    struct {
+        unsigned char NaN_Bytes[8];
+        unsigned char Inf_Bytes[8];
+    } bytes;
+    
+    struct {
+        double NaN_Double;
+        double Inf_Double;
+    } doubles;
+    
+} NaNInf = { {
+#if PLATFORM(BIG_ENDIAN)
+    { 0x7f, 0xf8, 0, 0, 0, 0, 0, 0 },
+    { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 }
+#elif PLATFORM(MIDDLE_ENDIAN)
+    { 0, 0, 0xf8, 0x7f, 0, 0, 0, 0 },
+    { 0, 0, 0xf0, 0x7f, 0, 0, 0, 0 }
+#else
+    { 0, 0, 0, 0, 0, 0, 0xf8, 0x7f },
+    { 0, 0, 0, 0, 0, 0, 0xf0, 0x7f }
+#endif
+} } ;
+
+extern const double NaN = NaNInf.doubles.NaN_Double;
+extern const double Inf = NaNInf.doubles.Inf_Double;
+ 
+#endif // !(defined NAN && defined INFINITY)
 
 static const double D16 = 65536.0;