Removing HP_TIMING_ACCUM as unused

9 files changed, 12 insertions, 145 deletions

diff --git a/sysdeps/alpha/hp-timing.h b/sysdeps/alpha/hp-timing.h
index 4cbee66e7f..71322f9773 100644
--- a/sysdeps/alpha/hp-timing.h
+++ b/sysdeps/alpha/hp-timing.h
@@ -51,13 +51,8 @@
    - HP_TIMING_DIFF: compute difference between two times and store it
      in a third.  Source and destination might overlap.
 
-   - HP_TIMING_ACCUM: add time difference to another variable.  This might
-     be a bit more complicated to implement for some platforms as the
-     operation should be thread-safe and 64bit arithmetic on 32bit platforms
-     is not.
-
-   - HP_TIMING_ACCUM_NT: this is the variant for situations where we know
-     there are no threads involved.
+   - HP_TIMING_ACCUM_NT: add time difference to another variable, without
+     being thread-safe.
 
    - HP_TIMING_PRINT: write decimal representation of the timing value into
      the given string.  This operation need not be inline even though
@@ -91,10 +86,6 @@ typedef unsigned int hp_timing_t;
 /* It's simple arithmetic for us.  */
 #define HP_TIMING_DIFF(Diff, Start, End)	(Diff) = ((End) - (Start))
 
-/* ??? Don't bother, since we're only used for ld.so.  */
-#define HP_TIMING_ACCUM(Sum, Diff)  not implemented
-
-/* No threads, no extra work.  */
 #define HP_TIMING_ACCUM_NT(Sum, Diff)	(Sum) += (Diff)
 
 /* Print the time value.  */
diff --git a/sysdeps/generic/hp-timing.h b/sysdeps/generic/hp-timing.h
index bf78e4e9d6..894ab17236 100644
--- a/sysdeps/generic/hp-timing.h
+++ b/sysdeps/generic/hp-timing.h
@@ -48,13 +48,8 @@
    - HP_TIMING_DIFF: compute difference between two times and store it
      in a third.  Source and destination might overlap.
 
-   - HP_TIMING_ACCUM: add time difference to another variable.  This might
-     be a bit more complicated to implement for some platforms as the
-     operation should be thread-safe and 64bit arithmetic on 32bit platforms
-     is not.
-
-   - HP_TIMING_ACCUM_NT: this is the variant for situations where we know
-     there are no threads involved.
+   - HP_TIMING_ACCUM_NT: add time difference to another variable, without
+     being thread-safe.
 
    - HP_TIMING_PRINT: write decimal representation of the timing value into
      the given string.  This operation need not be inline even though
@@ -69,7 +64,6 @@ typedef int hp_timing_t;
 #define HP_TIMING_NOW(var)
 #define HP_TIMING_DIFF_INIT()
 #define HP_TIMING_DIFF(Diff, Start, End)
-#define HP_TIMING_ACCUM(Sum, Diff)
 #define HP_TIMING_ACCUM_NT(Sum, Diff)
 #define HP_TIMING_PRINT(Buf, Len, Val)
 
diff --git a/sysdeps/i386/i686/hp-timing.h b/sysdeps/i386/i686/hp-timing.h
index 18e5b95bbe..a4b19c1043 100644
--- a/sysdeps/i386/i686/hp-timing.h
+++ b/sysdeps/i386/i686/hp-timing.h
@@ -58,13 +58,8 @@
    - HP_TIMING_DIFF: compute difference between two times and store it
      in a third.  Source and destination might overlap.
 
-   - HP_TIMING_ACCUM: add time difference to another variable.  This might
-     be a bit more complicated to implement for some platforms as the
-     operation should be thread-safe and 64bit arithmetic on 32bit platforms
-     is not.
-
-   - HP_TIMING_ACCUM_NT: this is the variant for situations where we know
-     there are no threads involved.
+   - HP_TIMING_ACCUM_NT: add time difference to another variable, without
+     being thread-safe.
 
    - HP_TIMING_PRINT: write decimal representation of the timing value into
      the given string.  This operation need not be inline even though
@@ -110,30 +105,6 @@ typedef unsigned long long int hp_timing_t;
 /* It's simple arithmetic for us.  */
 #define HP_TIMING_DIFF(Diff, Start, End)	(Diff) = ((End) - (Start))
 
-/* We have to jump through hoops to get this correctly implemented.  */
-#define HP_TIMING_ACCUM(Sum, Diff) \
-  do {									      \
-    int __not_done;							      \
-    hp_timing_t __oldval = (Sum);					      \
-    hp_timing_t __diff = (Diff) - GLRO(dl_hp_timing_overhead);		      \
-    do									      \
-      {									      \
-	hp_timing_t __newval = __oldval + __diff;			      \
-	int __temp0, __temp1;						      \
-	__asm__ __volatile__ ("xchgl %0, %%ebx\n\t"			      \
-			      "lock; cmpxchg8b %1\n\t"			      \
-			      "sete %%bl\n\t"				      \
-			      "xchgl %0, %%ebx"				      \
-			      : "=SD" (__not_done), "=m" (Sum),		      \
-				"=A" (__oldval), "=c" (__temp0)		      \
-			      : "m" (Sum), "2" (__oldval),		      \
-				"3" ((unsigned int) (__newval >> 32)),	      \
-				"0" ((unsigned int) __newval));		      \
-      }									      \
-    while ((unsigned char) __not_done);					      \
-  } while (0)
-
-/* No threads, no extra work.  */
 #define HP_TIMING_ACCUM_NT(Sum, Diff)	(Sum) += (Diff)
 
 /* Print the time value.  */
diff --git a/sysdeps/ia64/hp-timing.h b/sysdeps/ia64/hp-timing.h
index e91326c8d0..ccc49e63ce 100644
--- a/sysdeps/ia64/hp-timing.h
+++ b/sysdeps/ia64/hp-timing.h
@@ -52,13 +52,8 @@
    - HP_TIMING_DIFF: compute difference between two times and store it
      in a third.  Source and destination might overlap.
 
-   - HP_TIMING_ACCUM: add time difference to another variable.  This might
-     be a bit more complicated to implement for some platforms as the
-     operation should be thread-safe and 64bit arithmetic on 32bit platforms
-     is not.
-
-   - HP_TIMING_ACCUM_NT: this is the variant for situations where we know
-     there are no threads involved.
+   - HP_TIMING_ACCUM_NT: add time difference to another variable, without
+     being thread-safe.
 
    - HP_TIMING_PRINT: write decimal representation of the timing value into
      the given string.  This operation need not be inline even though
@@ -108,21 +103,6 @@ typedef unsigned long int hp_timing_t;
 /* It's simple arithmetic for us.  */
 #define HP_TIMING_DIFF(Diff, Start, End)	(Diff) = ((End) - (Start))
 
-/* We have to jump through hoops to get this correctly implemented.  */
-#define HP_TIMING_ACCUM(Sum, Diff) \
-  do {									      \
-    hp_timing_t __oldval;						      \
-    hp_timing_t __diff = (Diff) - GLRO(dl_hp_timing_overhead);		      \
-    hp_timing_t __newval;						      \
-    do									      \
-      {									      \
-	__oldval = (Sum);						      \
-	__newval = __oldval + __diff;					      \
-      }									      \
-    while (! __sync_bool_compare_and_swap (&Sum, __oldvar, __newval));	      \
-  } while (0)
-
-/* No threads, no extra work.  */
 #define HP_TIMING_ACCUM_NT(Sum, Diff)	(Sum) += (Diff)
 
 /* Print the time value.  */
diff --git a/sysdeps/powerpc/powerpc32/power4/hp-timing.h b/sysdeps/powerpc/powerpc32/power4/hp-timing.h
index 2124e02081..cd296c52e2 100644
--- a/sysdeps/powerpc/powerpc32/power4/hp-timing.h
+++ b/sysdeps/powerpc/powerpc32/power4/hp-timing.h
@@ -51,13 +51,8 @@
    - HP_TIMING_DIFF: compute difference between two times and store it
      in a third.  Source and destination might overlap.
 
-   - HP_TIMING_ACCUM: add time difference to another variable.  This might
-     be a bit more complicated to implement for some platforms as the
-     operation should be thread-safe and 64bit arithmetic on 32bit platforms
-     is not.
-
-   - HP_TIMING_ACCUM_NT: this is the variant for situations where we know
-     there are no threads involved.
+   - HP_TIMING_ACCUM_NT: add time difference to another variable, without
+     being thread-safe.
 
    - HP_TIMING_PRINT: write decimal representation of the timing value into
      the given string.  This operation need not be inline even though
@@ -117,15 +112,6 @@ typedef unsigned long long int hp_timing_t;
 /* It's simple arithmetic in 64-bit.  */
 #define HP_TIMING_DIFF(Diff, Start, End)	(Diff) = ((End) - (Start))
 
-/* We need to insure that this add is atomic in threaded environments.  We use
-   __arch_atomic_exchange_and_add_64 from atomic.h to get thread safety.  */
-#define HP_TIMING_ACCUM(Sum, Diff) \
-  do {									      \
-    hp_timing_t __diff = (Diff) - GLRO(dl_hp_timing_overhead);		      \
-    __arch_atomic_exchange_and_add_64 (&(Sum), __diff);	                      \
-  } while (0)
-
-/* No threads, no extra work.  */
 #define HP_TIMING_ACCUM_NT(Sum, Diff)	(Sum) += (Diff)
 
 /* Print the time value.  */
diff --git a/sysdeps/powerpc/powerpc64/hp-timing.h b/sysdeps/powerpc/powerpc64/hp-timing.h
index c773541e67..4cad90afa1 100644
--- a/sysdeps/powerpc/powerpc64/hp-timing.h
+++ b/sysdeps/powerpc/powerpc64/hp-timing.h
@@ -51,13 +51,8 @@
    - HP_TIMING_DIFF: compute difference between two times and store it
      in a third.  Source and destination might overlap.
 
-   - HP_TIMING_ACCUM: add time difference to another variable.  This might
-     be a bit more complicated to implement for some platforms as the
-     operation should be thread-safe and 64bit arithmetic on 32bit platforms
-     is not.
-
-   - HP_TIMING_ACCUM_NT: this is the variant for situations where we know
-     there are no threads involved.
+   - HP_TIMING_ACCUM_NT: add time difference to another variable, without
+     being thread-safe.
 
    - HP_TIMING_PRINT: write decimal representation of the timing value into
      the given string.  This operation need not be inline even though
@@ -108,15 +103,6 @@ typedef unsigned long long int hp_timing_t;
 /* It's simple arithmetic in 64-bit.  */
 #define HP_TIMING_DIFF(Diff, Start, End)	(Diff) = ((End) - (Start))
 
-/* We need to insure that this add is atomic in threaded environments.  We use
-   __arch_atomic_exchange_and_add_64 from atomic.h to get thread safety.  */
-#define HP_TIMING_ACCUM(Sum, Diff) \
-  do {									      \
-    hp_timing_t __diff = (Diff) - GLRO(dl_hp_timing_overhead);		      \
-    __arch_atomic_exchange_and_add_64 (&(Sum), __diff);	                      \
-  } while (0)
-
-/* No threads, no extra work.  */
 #define HP_TIMING_ACCUM_NT(Sum, Diff)	(Sum) += (Diff)
 
 /* Print the time value.  */
diff --git a/sysdeps/sparc/sparc32/sparcv9/hp-timing.h b/sysdeps/sparc/sparc32/sparcv9/hp-timing.h
index fbfb8615be..c3be1ca944 100644
--- a/sysdeps/sparc/sparc32/sparcv9/hp-timing.h
+++ b/sysdeps/sparc/sparc32/sparcv9/hp-timing.h
@@ -51,23 +51,6 @@ typedef unsigned long long int hp_timing_t;
 
 #define HP_TIMING_DIFF(Diff, Start, End)	(Diff) = ((End) - (Start))
 
-#define HP_TIMING_ACCUM(Sum, Diff)				\
-do {								\
-  hp_timing_t __diff = (Diff) - GLRO(dl_hp_timing_overhead);	\
-  __asm__ __volatile__("srl	%L0, 0, %%g1\n\t"		\
-		       "sllx	%H0, 32, %%g6\n\t"		\
-		       "or	%%g1, %%g6, %%g1\n\t"		\
-		       "1: ldx	[%1], %%g5\n\t"			\
-		       "add	%%g5, %%g1, %%g6\n\t"		\
-		       "casx	[%1], %%g5,  %%g6\n\t"		\
-		       "cmp	%%g5, %%g6\n\t"			\
-		       "bne,pn	%%xcc, 1b\n\t"			\
-		       " nop"					\
-		       : /* no outputs */			\
-		       : "r" (__diff), "r" (&(Sum))		\
-		       : "memory", "g1", "g5", "g6");		\
-} while(0)
-
 #define HP_TIMING_ACCUM_NT(Sum, Diff)	(Sum) += (Diff)
 
 #define HP_TIMING_PRINT(Buf, Len, Val) \
diff --git a/sysdeps/sparc/sparc64/hp-timing.h b/sysdeps/sparc/sparc64/hp-timing.h
index 0773efb610..9e49b7841b 100644
--- a/sysdeps/sparc/sparc64/hp-timing.h
+++ b/sysdeps/sparc/sparc64/hp-timing.h
@@ -48,21 +48,6 @@ typedef unsigned long int hp_timing_t;
 
 #define HP_TIMING_DIFF(Diff, Start, End)	(Diff) = ((End) - (Start))
 
-#define HP_TIMING_ACCUM(Sum, Diff)				\
-do {								\
-  hp_timing_t __diff = (Diff) - GLRO(dl_hp_timing_overhead);	\
-  hp_timing_t tmp1, tmp2;					\
-  __asm__ __volatile__("1: ldx	[%3], %0\n\t"			\
-		       "add	%0, %2, %1\n\t"			\
-		       "casx	[%3], %0,  %1\n\t"		\
-		       "cmp	%0, %1\n\t"			\
-		       "bne,pn	%%xcc, 1b\n\t"			\
-		       " nop"					\
-		       : "=&r" (tmp1), "=&r" (tmp2)		\
-		       : "r" (__diff), "r" (&(Sum))		\
-		       : "memory", "g1", "g5", "g6");		\
-} while(0)
-
 #define HP_TIMING_ACCUM_NT(Sum, Diff)	(Sum) += (Diff)
 
 #define HP_TIMING_PRINT(Buf, Len, Val) \
diff --git a/sysdeps/x86_64/hp-timing.h b/sysdeps/x86_64/hp-timing.h
index d88206c6e3..e132dacab6 100644
--- a/sysdeps/x86_64/hp-timing.h
+++ b/sysdeps/x86_64/hp-timing.h
@@ -28,13 +28,4 @@
      asm volatile ("rdtsc" : "=a" (_lo), "=d" (_hi)); \
      (Var) = ((unsigned long long int) _hi << 32) | _lo; })
 
-/* The funny business for 32-bit mode is not required here.  */
-# undef HP_TIMING_ACCUM
-# define HP_TIMING_ACCUM(Sum, Diff)					      \
-  do {									      \
-    hp_timing_t __diff = (Diff) - GLRO(dl_hp_timing_overhead);		      \
-    __asm__ __volatile__ ("lock; addq %1, %0"				      \
-			  : "=m" (Sum) : "r" (__diff), "m" (Sum));	      \
-  } while (0)
-
 #endif /* hp-timing.h */