Remove unneeded ; after *_alias

libpthread/linuxthreads/attr.c

@@ -52,7 +52,7 @@ int __pthread_attr_destroy(pthread_attr_t *attr)
 {
   return 0;
 }
-strong_alias (__pthread_attr_destroy, pthread_attr_destroy);
+strong_alias (__pthread_attr_destroy, pthread_attr_destroy)
 
 int __pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
 {
@@ -62,14 +62,14 @@ int __pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
   attr->__detachstate = detachstate;
   return 0;
 }
-strong_alias (__pthread_attr_setdetachstate, pthread_attr_setdetachstate);
+strong_alias (__pthread_attr_setdetachstate, pthread_attr_setdetachstate)
 
 int __pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
 {
   *detachstate = attr->__detachstate;
   return 0;
 }
-strong_alias (__pthread_attr_getdetachstate, pthread_attr_getdetachstate);
+strong_alias (__pthread_attr_getdetachstate, pthread_attr_getdetachstate)
 
 int __pthread_attr_setschedparam(pthread_attr_t *attr,
                                  const struct sched_param *param)
@@ -82,7 +82,7 @@ int __pthread_attr_setschedparam(pthread_attr_t *attr,
   memcpy (&attr->__schedparam, param, sizeof (struct sched_param));
   return 0;
 }
-strong_alias (__pthread_attr_setschedparam, pthread_attr_setschedparam);
+strong_alias (__pthread_attr_setschedparam, pthread_attr_setschedparam)
 
 int __pthread_attr_getschedparam(const pthread_attr_t *attr,
                                  struct sched_param *param)
@@ -90,7 +90,7 @@ int __pthread_attr_getschedparam(const pthread_attr_t *attr,
   memcpy (param, &attr->__schedparam, sizeof (struct sched_param));
   return 0;
 }
-strong_alias (__pthread_attr_getschedparam, pthread_attr_getschedparam);
+strong_alias (__pthread_attr_getschedparam, pthread_attr_getschedparam)
 
 int __pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy)
 {
@@ -99,14 +99,14 @@ int __pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy)
   attr->__schedpolicy = policy;
   return 0;
 }
-strong_alias (__pthread_attr_setschedpolicy, pthread_attr_setschedpolicy);
+strong_alias (__pthread_attr_setschedpolicy, pthread_attr_setschedpolicy)
 
 int __pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy)
 {
   *policy = attr->__schedpolicy;
   return 0;
 }
-strong_alias (__pthread_attr_getschedpolicy, pthread_attr_getschedpolicy);
+strong_alias (__pthread_attr_getschedpolicy, pthread_attr_getschedpolicy)
 
 int __pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit)
 {
@@ -115,14 +115,14 @@ int __pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit)
   attr->__inheritsched = inherit;
   return 0;
 }
-strong_alias (__pthread_attr_setinheritsched, pthread_attr_setinheritsched);
+strong_alias (__pthread_attr_setinheritsched, pthread_attr_setinheritsched)
 
 int __pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit)
 {
   *inherit = attr->__inheritsched;
   return 0;
 }
-strong_alias (__pthread_attr_getinheritsched, pthread_attr_getinheritsched);
+strong_alias (__pthread_attr_getinheritsched, pthread_attr_getinheritsched)
 
 int __pthread_attr_setscope(pthread_attr_t *attr, int scope)
 {
@@ -136,14 +136,14 @@ int __pthread_attr_setscope(pthread_attr_t *attr, int scope)
     return EINVAL;
   }
 }
-strong_alias (__pthread_attr_setscope, pthread_attr_setscope);
+strong_alias (__pthread_attr_setscope, pthread_attr_setscope)
 
 int __pthread_attr_getscope(const pthread_attr_t *attr, int *scope)
 {
   *scope = attr->__scope;
   return 0;
 }
-strong_alias (__pthread_attr_getscope, pthread_attr_getscope);
+strong_alias (__pthread_attr_getscope, pthread_attr_getscope)
 
 int __pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize)
 {

libpthread/linuxthreads/cancel.c

@@ -43,7 +43,7 @@ int __pthread_setcancelstate(int state, int * oldstate)
     __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
   return 0;
 }
-strong_alias (__pthread_setcancelstate, pthread_setcancelstate);
+strong_alias (__pthread_setcancelstate, pthread_setcancelstate)
 
 int __pthread_setcanceltype(int type, int * oldtype)
 {
@@ -58,7 +58,7 @@ int __pthread_setcanceltype(int type, int * oldtype)
     __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
   return 0;
 }
-strong_alias (__pthread_setcanceltype, pthread_setcanceltype);
+strong_alias (__pthread_setcanceltype, pthread_setcanceltype)
 
 
 /* The next two functions are similar to pthread_setcanceltype() but

libpthread/linuxthreads/forward.c

@@ -102,7 +102,7 @@ FORWARD (pthread_equal, (pthread_t thread1, pthread_t thread2),
 
 /* Use an alias to avoid warning, as pthread_exit is declared noreturn.  */
 FORWARD2 (__pthread_exit, void, (void *retval), (retval), exit (EXIT_SUCCESS))
-strong_alias (__pthread_exit, pthread_exit);
+strong_alias (__pthread_exit, pthread_exit)
 
 
 FORWARD (pthread_getschedparam,

libpthread/linuxthreads/join.c

@@ -28,7 +28,7 @@ void __pthread_exit(void * retval)
 {
   __pthread_do_exit (retval, CURRENT_STACK_FRAME);
 }
-strong_alias (__pthread_exit, pthread_exit);
+strong_alias (__pthread_exit, pthread_exit)
 
 void __pthread_do_exit(void *retval, char *currentframe)
 {

libpthread/linuxthreads/libc-cancellation.c

@@ -32,7 +32,7 @@ weak_extern (__pthread_do_exit)
 # endif
 
 int __libc_multiple_threads attribute_hidden __attribute__((nocommon));
-strong_alias (__libc_multiple_threads, __librt_multiple_threads);
+strong_alias (__libc_multiple_threads, __librt_multiple_threads)
 
 /* The next two functions are similar to pthread_setcanceltype() but
    more specialized for the use in the cancelable functions like write().

libpthread/linuxthreads/ptfork.c

@@ -83,11 +83,11 @@ pid_t __fork (void)
 {
   return __libc_fork ();
 }
-weak_alias (__fork, fork);
+weak_alias (__fork, fork)
 
 pid_t __vfork(void)
 {
   return __libc_fork ();
 }
-weak_alias (__vfork, vfork);
+weak_alias (__vfork, vfork)
 #endif

libpthread/linuxthreads/pthread.c

@@ -849,13 +849,13 @@ pthread_t __pthread_self(void)
   pthread_descr self = thread_self();
   return THREAD_GETMEM(self, p_tid);
 }
-strong_alias (__pthread_self, pthread_self);
+strong_alias (__pthread_self, pthread_self)
 
 int __pthread_equal(pthread_t thread1, pthread_t thread2)
 {
   return thread1 == thread2;
 }
-strong_alias (__pthread_equal, pthread_equal);
+strong_alias (__pthread_equal, pthread_equal)
 
 /* Helper function for thread_self in the case of user-provided stacks */
 
@@ -936,7 +936,7 @@ int __pthread_setschedparam(pthread_t thread, int policy,
     __pthread_manager_adjust_prio(th->p_priority);
   return 0;
 }
-strong_alias (__pthread_setschedparam, pthread_setschedparam);
+strong_alias (__pthread_setschedparam, pthread_setschedparam)
 
 int __pthread_getschedparam(pthread_t thread, int *policy,
                             struct sched_param *param)
@@ -957,7 +957,7 @@ int __pthread_getschedparam(pthread_t thread, int *policy,
   *policy = pol;
   return 0;
 }
-strong_alias (__pthread_getschedparam, pthread_getschedparam);
+strong_alias (__pthread_getschedparam, pthread_getschedparam)
 
 /* Process-wide exit() request */
 

libpthread/linuxthreads/sysdeps/unix/sysv/linux/allocrtsig.c

@@ -56,7 +56,7 @@ __libc_current_sigrtmin (void)
     init ();
   return current_rtmin;
 }
-strong_alias (__libc_current_sigrtmin, __libc_current_sigrtmin_private);
+strong_alias (__libc_current_sigrtmin, __libc_current_sigrtmin_private)
 libc_hidden_def (__libc_current_sigrtmin)
 
 /* Return number of available real-time signal with lowest priority.  */
@@ -67,7 +67,7 @@ __libc_current_sigrtmax (void)
     init ();
   return current_rtmax;
 }
-strong_alias (__libc_current_sigrtmax, __libc_current_sigrtmax_private);
+strong_alias (__libc_current_sigrtmax, __libc_current_sigrtmax_private)
 libc_hidden_def (__libc_current_sigrtmax)
 
 /* Allocate real-time signal with highest/lowest available
@@ -84,4 +84,4 @@ __libc_allocate_rtsig (int high)
 
   return high ? current_rtmin++ : current_rtmax--;
 }
-strong_alias (__libc_allocate_rtsig, __libc_allocate_rtsig_private);
+strong_alias (__libc_allocate_rtsig, __libc_allocate_rtsig_private)