if (size / pagesize > phys_pages)
if (size / pagesize > (size_t) phys_pages)
qsort (void *b, size_t n, size_t s, __compar_fn_t cmp){  const size_t size = n * s;  if (size < 1024)    {      void *buf = __alloca (size);      /* The temporary array is small, so put it on the stack.  */      msort_with_tmp (b, n, s, cmp, buf);    }  else    {      /* We should avoid allocating too much memory since this might	 have to be backed up by swap space.  */      static long int phys_pages;      static int pagesize;      if (phys_pages == 0)	{	  phys_pages = __sysconf (_SC_PHYS_PAGES);	  if (phys_pages == -1)	    /* Error while determining the memory size.  So let's	       assume there is enough memory.  Otherwise the	       implementer should provide a complete implementation of	       the `sysconf' function.  */	    phys_pages = (long int) (~0ul >> 1);	  /* The following determines that we will never use more than	     a quarter of the physical memory.  */	  phys_pages /= 4;	  pagesize = __sysconf (_SC_PAGESIZE);	}      /* Just a comment here.  We cannot compute	   phys_pages * pagesize	   and compare the needed amount of memory against this value.	   The problem is that some systems might have more physical	   memory then can be represented with a `size_t' value (when	   measured in bytes.  */      /* If the memory requirements are too high don't allocate memory.  */      if (size / pagesize > phys_pages)	_quicksort (b, n, s, cmp);      else	{	  /* It's somewhat large, so malloc it.  */	  int save = errno;	  char *tmp = malloc (size);	  if (tmp == NULL)	    {	      /* Couldn't get space, so use the slower algorithm		 that doesn't need a temporary array.  */	      __set_errno (save);	      _quicksort (b, n, s, cmp);	    }	  else	    {	      __set_errno (save);	      msort_with_tmp (b, n, s, cmp, tmp);	      free (tmp);	    }	}    }}