Cannot compile uClibc-ng with the Clang compiler... about uclibc-ng HOT 11 OPEN

/* In case of a fork() call the memory allocation in the child will be
   the same but only one thread is running.  All stacks except that of
   the one running thread are not used anymore.  We have to recycle
   them.  */
void
__reclaim_stacks (void)
{
  struct pthread *self = (struct pthread *) THREAD_SELF;
    .
    .
    .
  if (in_flight_stack != 0)
    {
      bool add_p = in_flight_stack & 1;
      list_t *elem = (list_t *)(uintptr_t)(in_flight_stack & ~UINTMAX_C (1));

      if (add_p)
	{
	  /* We always add at the beginning of the list.  So in this
	     case we only need to check the beginning of these lists.  */
	  int check_list (list_t *l)
	  {
	    if (l->next->prev != l)
	      {
		assert (l->next->prev == elem);

		elem->next = l->next;
		elem->prev = l;
		l->next = elem;

		return 1;
	      }

	    return 0;
	  }

	  if (check_list (&stack_used) == 0)
	    (void) check_list (&stack_cache);
	}
      else
	{
	  /* We can simply always replay the delete operation.  */
	  elem->next->prev = elem->prev;
	  elem->prev->next = elem->next;
	}
    }
    .
    .
    .
}

  /* We always add at the beginning of the list.  So in this
     case we only need to check the beginning of these lists.  */
static inline int __attribute__((always_inline))
check_list (list_t *l, list_t **elemPtr)
  {
   list_t elem = *elemPtr;

    if (l->next->prev != l)
      {
	assert (l->next->prev == elem);

	elem->next = l->next;
	elem->prev = l;
	l->next = elem;

	return 1;
      }

    return 0;
  }

/* In case of a fork() call the memory allocation in the child will be
   the same but only one thread is running.  All stacks except that of
   the one running thread are not used anymore.  We have to recycle
   them.  */
void
__reclaim_stacks (void)
{
  struct pthread *self = (struct pthread *) THREAD_SELF;
    .
    .
    .
  if (in_flight_stack != 0)
    {
      bool add_p = in_flight_stack & 1;
      list_t *elem = (list_t *)(uintptr_t)(in_flight_stack & ~UINTMAX_C (1));

      if (add_p)
	{
	  if (check_list (&stack_used, &elem) == 0)
	    (void) check_list (&stack_cache, &elem);
	}
      else
	{
	  /* We can simply always replay the delete operation.  */
	  elem->next->prev = elem->prev;
	  elem->prev->next = elem->next;
	}
    }
    .
    .
    .
}

__asm__("@@@name@@@<constant-name>@@@value@@@%0@@@end@@@" " "i" ((long) sizeof(<structure-name>)));

__asm__("#define <constant-name> %0" " "i" ((long) sizeof(<structure-name>)));

        #define <constant-name> $<constant-value>

diff --git a/libpthread/nptl/allocatestack.c b/libpthread/nptl/allocatestack.c
index 137979542..e7e0b4d8f 100644
--- a/libpthread/nptl/allocatestack.c
+++ b/libpthread/nptl/allocatestack.c
@@ -773,6 +773,25 @@ __make_stacks_executable (void **stack_endp)
   return err;
 }
 
+/* We always add at the beginning of the list.  So in this
+   case we only need to check the beginning of these lists.  */
+static inline int __attribute__((always_inline))
+check_list (list_t *l, list_t **elemPtr)
+{
+  list_t *elem = *elemPtr;
+  if (l->next->prev != l)
+    {
+      assert (l->next->prev == elem);
+
+      elem->next = l->next;
+      elem->prev = l;
+      l->next = elem;
+
+      return 1;
+    }
+
+  return 0;
+}
 
 /* In case of a fork() call the memory allocation in the child will be
    the same but only one thread is running.  All stacks except that of
@@ -794,26 +813,8 @@ __reclaim_stacks (void)
 
       if (add_p)
 	{
-	  /* We always add at the beginning of the list.  So in this
-	     case we only need to check the beginning of these lists.  */
-	  int check_list (list_t *l)
-	  {
-	    if (l->next->prev != l)
-	      {
-		assert (l->next->prev == elem);
-
-		elem->next = l->next;
-		elem->prev = l;
-		l->next = elem;
-
-		return 1;
-	      }
-
-	    return 0;
-	  }
-
-	  if (check_list (&stack_used) == 0)
-	    (void) check_list (&stack_cache);
+	  if (check_list (&stack_used, &elem) == 0)
+	    (void) check_list (&stack_cache, &elem);
 	}
       else
 	{

jne,pt 10f