1 files changed, 36 insertions, 92 deletions

diff --git a/libjava/include/java-cpool.h b/libjava/include/java-cpool.h
index f4d7ef9910a..b5e3ab36db7 100644
--- a/libjava/include/java-cpool.h
+++ b/libjava/include/java-cpool.h
@@ -31,142 +31,86 @@ details.  */
 #define JV_CONSTANT_ResolvedString (16L | 8L)
 #define JV_CONSTANT_ResolvedClass  (16L | 7L)
 
-/* We use the following two operations uniformly for all put/get operations
- * in the runtime system (constant pool & stack), to assure that we keep
- * everything in the same format.  The idea is, that these should be inlined
- * away, into just a simple store (for small data types, and a pair of stores
- * if double or long has alignment greater than void *.  On an 64-bit
- * architecture, all operations should be simple stores; on a 32-bit
- * architecture it depends on the alignment requirement for the specific
- * type.  */
-
-template <class T>
-static inline void _Jv_put (void *dst, T value)
-{
-#if 0
-  if (sizeof (T) == 8 && __alignof__ (T) > __alignof__ (void*))
-    {
-      jint *v_dst  = (jint*)(dst);
-      jint *v_src  = (jint*)&value;
-
-      v_dst[0] = v_src[0];
-      v_dst[1] = v_src[1];
-    }
-  else 
-#endif
-    {
-      *((T*) (dst)) = value;
-    }
-}
-
-template <class T>
-static inline T _Jv_get (void *src)
-{
-#if 0
-  if (sizeof (T) == 8 && __alignof__ (T) > __alignof__ (void*))
-    {
-      T     value;
-      jint *v_dst  = (jint*)&value;
-      jint *v_src  = (jint*)src;
-
-      v_dst[0] = v_src[0];
-      v_dst[1] = v_src[1];
-
-      return value;
-    }
-  else 
-#endif
-    {
-      return *((T*) (src));
-    }
-}
-
-/** needed to keep the CONSTANT_XXXRef & CONSTANT_NameAndType entries */
 extern inline void 
-_Jv_storeIndexes (void **data,
+_Jv_storeIndexes (_Jv_word *data,
 		 _Jv_ushort index0,
 		 _Jv_ushort index1)
 {
-  // accomodate 64bit machines...
-  if (sizeof (void*) == (2 * sizeof (jint)))
-    {
-      ((jint*)data)[0] = index0;
-      ((jint*)data)[1] = index0;
-    }
-  else
-    {
-      _Jv_put<jint>(data, ((jint)index0 << 16) | (jint)index1);
-    }
+  data->i = (((jint)index0) << 16) | (jint) index1;
 }
 
 extern inline void 
-_Jv_loadIndexes (const void **data,
+_Jv_loadIndexes (const _Jv_word *data,
 		 _Jv_ushort& index0,
 		 _Jv_ushort& index1)
 {
-  if (sizeof (void*) == (2*sizeof (jint)))
-    {
-      index0 = ((jint*)data)[0];
-      index0 = ((jint*)data)[1];
-    }
-  else
-    {
-      jint udata = _Jv_get<jint>(data);
+  jint udata = data->i;
       
-      _Jv_uint uindex0 = ((udata >> 16) & 0xffff);
-      _Jv_uint uindex1 = udata & 0xffff;
+  _Jv_uint uindex0 = ((udata >> 16) & 0xffff);
+  _Jv_uint uindex1 = udata & 0xffff;
       
-      index0 = uindex0;
-      index1 = uindex1;
-    }
+  index0 = uindex0;
+  index1 = uindex1;
 }
 
 extern inline void
-_Jv_storeFloat (void **data, jfloat f)
+_Jv_storeFloat (_Jv_word *data, jfloat f)
 {
-  _Jv_put<jfloat>(data, f);
+  data->f = f;
 }
 
 extern inline jfloat
-_Jv_loadFloat (void **data)
+_Jv_loadFloat (_Jv_word *data)
 {
-  return _Jv_get<jfloat>(data);
+  return data->f;
 }
 
 extern inline void
-_Jv_storeInt (void **data, jint i)
+_Jv_storeInt (_Jv_word *data, jint i)
 {
-  _Jv_put<jint>(data, i);
+  data->i = i;
 }
 
 extern inline jint
-_Jv_loadInt (void **data)
+_Jv_loadInt (_Jv_word *data)
 {
-  return _Jv_get<jint>(data);
+  return data->i;
 }
 
 extern inline void
-_Jv_storeLong (void **data, jlong l)
+_Jv_storeLong (_Jv_word *data, jlong l)
 {
-  return _Jv_put<jlong>(data, l);
+  _Jv_word2 tmp;
+  tmp.l = l;
+  data[0].ia[0] = tmp.ia[0];
+  data[1].ia[0] = tmp.ia[1];
 }
 
 extern inline jlong
-_Jv_loadLong (void **data)
+_Jv_loadLong (_Jv_word *data)
 {
-  return _Jv_get<jlong>(data);
+  _Jv_word2 tmp;
+  tmp.ia[0] = data[0].ia[0];
+  tmp.ia[1] = data[1].ia[0];
+  return tmp.l;
 }
 
 extern inline void
-_Jv_storeDouble (void **data, jdouble d)
+_Jv_storeDouble (_Jv_word *data, jdouble d)
 {
-  _Jv_put<jdouble>(data, d);
+  _Jv_word2 tmp;
+  tmp.d = d;
+  data[0].ia[0] = tmp.ia[0];
+  data[1].ia[0] = tmp.ia[1];
 }
 
 extern inline jdouble
-_Jv_loadDouble (void **data)
+_Jv_loadDouble (_Jv_word *data)
 {
-  return _Jv_get<jdouble> (data);
+  _Jv_word2 tmp;
+  tmp.ia[0] = data[0].ia[0];
+  tmp.ia[1] = data[1].ia[0];
+  return tmp.d;
 }