Re-establish mips basic infrastructure.

src/objects-inl.h

 // Copyright 2010 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 1172 matching lines @@
 
 void HeapObject::ClearOverflow() {
   ASSERT(IsOverflowed());
   MapWord first_word = map_word();
   first_word.ClearOverflow();
   set_map_word(first_word);
 }
 
 
 double HeapNumber::value() {
+#ifndef V8_TARGET_ARCH_MIPS
   return READ_DOUBLE_FIELD(this, kValueOffset);
+#else  // V8_TARGET_ARCH_MIPS

[Søren Thygesen Gjesse, 2011/03/21 16:05:19]

I think this should be put into the macro READ_DOUBLE_FIELD, and then there
should be two different macro definitions

#ifndef V8_TARGET_ARCH_MIPS
#define READ_DOUBLE_FIELD(p, offset) \
  <current definition>
#else
#define READ_DOUBLE_FIELD(p, offset) \
  <MIPS specific definition>
#endif

[Paul Lind, 2011/03/23 01:55:43]

The code has been moved to the READ_DOUBLE_FIELD macro as you suggest.

However, I saw no way to leave this as a pure macro, as the macro needs to
evaluate to an expression of type double that can be returned by HeapNumber::
value(). All approaches to multiline macros that I know (for instance, wrapping
in do { ... } while(0)), end up as a compound statement, not an expression.

Therefore I used a static inline function, and had the macro call that. I am
open to better suggestions.      

+  // Prevent gcc from using load-double (mips ldc1) on (possibly)
+  // non-64-bit aligned HeapNumber::value.
+  union conversion {
+    double d;
+    uint32_t u[2];
+  } c;
+  c.u[0] = (*reinterpret_cast<uint32_t*>(FIELD_ADDR(this, kValueOffset)));
+  c.u[1] = (*reinterpret_cast<uint32_t*>(FIELD_ADDR(this, kValueOffset + 4)));
+  return c.d;
+#endif  // V8_TARGET_ARCH_MIPS
 }
 
 
 void HeapNumber::set_value(double value) {
+#ifndef V8_TARGET_ARCH_MIPS
   WRITE_DOUBLE_FIELD(this, kValueOffset, value);
+#else  // V8_TARGET_ARCH_MIPS

[Søren Thygesen Gjesse, 2011/03/21 16:05:19]

Ditto.

[Paul Lind, 2011/03/23 01:55:43]

This one could have been implemented as pure macro, but I chose to implement
this with static inline, as was done above, for consistency.

Maybe the inline function names should me made more unique, possibly
mips_write_double_field()?

+  // Prevent gcc from using store-double (mips sdc1) on (possibly)
+  // non-64-bit aligned HeapNumber::value.
+  union conversion {
+    double d;
+    uint32_t u[2];
+  } c;
+  c.d = value;
+  (*reinterpret_cast<uint32_t*>(FIELD_ADDR(this, kValueOffset))) = c.u[0];
+  (*reinterpret_cast<uint32_t*>(FIELD_ADDR(this, kValueOffset + 4))) = c.u[1];
+#endif  // V8_TARGET_ARCH_MIPS
 }
 
 
 int HeapNumber::get_exponent() {
   return ((READ_INT_FIELD(this, kExponentOffset) & kExponentMask) >>
           kExponentShift) - kExponentBias;
 }
 
 
 int HeapNumber::get_sign() {
@@ skipping 2727 matching lines @@
 #undef WRITE_INT_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_