A64: Eliminate static initializers

src/a64/instructions-a64.h

 // Copyright 2013 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 22 matching lines @@
 #include "a64/constants-a64.h"
 #include "a64/utils-a64.h"
 
 namespace v8 {
 namespace internal {
 
 
 // ISA constants. --------------------------------------------------------------
 
 typedef uint32_t Instr;
-const float kFP32PositiveInfinity = rawbits_to_float(0x7f800000);
-const float kFP32NegativeInfinity = rawbits_to_float(0xff800000);
-const double kFP64PositiveInfinity = rawbits_to_double(0x7ff0000000000000UL);
-const double kFP64NegativeInfinity = rawbits_to_double(0xfff0000000000000UL);
+
+#if defined(A64_DEFINE_FP_STATICS)
+#define DEFINE_FLOAT(name, value) extern const uint32_t name = value

[Rodolph Perfetta (ARM), 2014/02/06 11:51:21]

did you mean to declare this extern and provide a value for it?

Anyway here we created a particular double from a bit pattern, you changed the
type to int so now the compiler will insert a cast and you'll get the double
conversion of the pattern not the bit pattern.

[jochen (gone - plz use gerrit), 2014/02/06 11:59:47]

no, that's not what will happen. The compiler will store the bit pattern in the
data segment, because I declared the store type as uint32_t/uint64_t

However, all sites that access the symbol will get the alternative definition
(line 48/49) which declares the store type as float/double. So the compiler
assumes that at this address, there is already a float/double and will just read
the bits without any conversion.

[Sven Panne, 2014/02/06 12:08:48]

http://media.giphy.com/media/3sjQViF0W1Mqs/giphy.gif
http://media.giphy.com/media/2K5uA7U4uZbVe/giphy.gif

;-) Couldn't resist...

+#define DEFINE_DOUBLE(name, value) extern const uint64_t name = value

[Rodolph Perfetta (ARM), 2014/02/06 11:51:21]

same here.

+#else
+#define DEFINE_FLOAT(name, value) extern const float name
+#define DEFINE_DOUBLE(name, value) extern const double name
+#endif  // defined(A64_DEFINE_FP_STATICS)
+
+DEFINE_FLOAT(kFP32PositiveInfinity, 0x7f800000);
+DEFINE_FLOAT(kFP32NegativeInfinity, 0xff800000);
+DEFINE_DOUBLE(kFP64PositiveInfinity, 0x7ff0000000000000UL);
+DEFINE_DOUBLE(kFP64NegativeInfinity, 0xfff0000000000000UL);
 
 // This value is a signalling NaN as both a double and as a float (taking the
 // least-significant word).
-static const double kFP64SignallingNaN = rawbits_to_double(0x7ff000007f800001);
-static const float kFP32SignallingNaN = rawbits_to_float(0x7f800001);
+DEFINE_DOUBLE(kFP64SignallingNaN, 0x7ff000007f800001);
+DEFINE_FLOAT(kFP32SignallingNaN, 0x7f800001);
 
 // A similar value, but as a quiet NaN.
-static const double kFP64QuietNaN = rawbits_to_double(0x7ff800007fc00001);
-static const float kFP32QuietNaN = rawbits_to_float(0x7fc00001);
+DEFINE_DOUBLE(kFP64QuietNaN, 0x7ff800007fc00001);
+DEFINE_FLOAT(kFP32QuietNaN, 0x7fc00001);
+
+#undef DEFINE_FLOAT
+#undef DEFINE_DOUBLE
 
 
 enum LSDataSize {
   LSByte        = 0,
   LSHalfword    = 1,
   LSWord        = 2,
   LSDoubleWord  = 3
 };
 
 LSDataSize CalcLSPairDataSize(LoadStorePairOp op);
@@ skipping 394 matching lines @@
   TRACE_ENABLE   = 1 << 6,
   TRACE_DISABLE  = 2 << 6,
   TRACE_OVERRIDE = 3 << 6
 };
 
 
 } }  // namespace v8::internal
 
 
 #endif  // V8_A64_INSTRUCTIONS_A64_H_