Use spaces for indentation, not tabs.

1 files changed, 36 insertions, 36 deletions

diff --git a/lib/memcmp.c b/lib/memcmp.c
index 01810715b0..98069b30ce 100644
--- a/lib/memcmp.c
+++ b/lib/memcmp.c
@@ -38,18 +38,18 @@
 #  define WORDS_BIGENDIAN
 # endif
 
-#else	/* Not in the GNU C library.  */
+#else   /* Not in the GNU C library.  */
 
 # include <sys/types.h>
 
 /* Type to use for aligned memory operations.
    This should normally be the biggest type supported by a single load
    and store.  Must be an unsigned type.  */
-# define op_t	unsigned long int
-# define OPSIZ	(sizeof(op_t))
+# define op_t   unsigned long int
+# define OPSIZ  (sizeof(op_t))
 
 /* Threshold value for when to enter the unrolled loops.  */
-# define OP_T_THRES	16
+# define OP_T_THRES     16
 
 /* Type to use for unaligned operations.  */
 typedef unsigned char byte;
@@ -60,7 +60,7 @@ typedef unsigned char byte;
 #  define MERGE(w0, sh_1, w1, sh_2) (((w0) << (sh_1)) | ((w1) >> (sh_2)))
 # endif
 
-#endif	/* In the GNU C library.  */
+#endif  /* In the GNU C library.  */
 
 #ifdef WORDS_BIGENDIAN
 # define CMP_LT_OR_GT(a, b) ((a) > (b) ? 1 : -1)
@@ -111,7 +111,7 @@ memcmp_bytes (op_t a, op_t b)
 /* memcmp_common_alignment -- Compare blocks at SRCP1 and SRCP2 with LEN `op_t'
    objects (not LEN bytes!).  Both SRCP1 and SRCP2 should be aligned for
    memory operations on `op_t's.  */
-#ifdef	__GNUC__
+#ifdef __GNUC__
 __inline
 #endif
 static int
@@ -139,7 +139,7 @@ memcmp_common_alignment (uintptr_t srcp1, uintptr_t srcp2, size_t len)
       goto do2;
     case 0:
       if (OP_T_THRES <= 3 * OPSIZ && len == 0)
-	return 0;
+        return 0;
       a0 = ((op_t *) srcp1)[0];
       b0 = ((op_t *) srcp2)[0];
       goto do3;
@@ -150,7 +150,7 @@ memcmp_common_alignment (uintptr_t srcp1, uintptr_t srcp2, size_t len)
       srcp2 += OPSIZ;
       len -= 1;
       if (OP_T_THRES <= 3 * OPSIZ && len == 0)
-	goto do0;
+        goto do0;
       /* Fall through.  */
     }
 
@@ -159,25 +159,25 @@ memcmp_common_alignment (uintptr_t srcp1, uintptr_t srcp2, size_t len)
       a0 = ((op_t *) srcp1)[0];
       b0 = ((op_t *) srcp2)[0];
       if (a1 != b1)
-	return CMP_LT_OR_GT (a1, b1);
+        return CMP_LT_OR_GT (a1, b1);
 
     do3:
       a1 = ((op_t *) srcp1)[1];
       b1 = ((op_t *) srcp2)[1];
       if (a0 != b0)
-	return CMP_LT_OR_GT (a0, b0);
+        return CMP_LT_OR_GT (a0, b0);
 
     do2:
       a0 = ((op_t *) srcp1)[2];
       b0 = ((op_t *) srcp2)[2];
       if (a1 != b1)
-	return CMP_LT_OR_GT (a1, b1);
+        return CMP_LT_OR_GT (a1, b1);
 
     do1:
       a1 = ((op_t *) srcp1)[3];
       b1 = ((op_t *) srcp2)[3];
       if (a0 != b0)
-	return CMP_LT_OR_GT (a0, b0);
+        return CMP_LT_OR_GT (a0, b0);
 
       srcp1 += 4 * OPSIZ;
       srcp2 += 4 * OPSIZ;
@@ -196,7 +196,7 @@ memcmp_common_alignment (uintptr_t srcp1, uintptr_t srcp2, size_t len)
 /* memcmp_not_common_alignment -- Compare blocks at SRCP1 and SRCP2 with LEN
    `op_t' objects (not LEN bytes!).  SRCP2 should be aligned for memory
    operations on `op_t', but SRCP1 *should be unaligned*.  */
-#ifdef	__GNUC__
+#ifdef __GNUC__
 __inline
 #endif
 static int
@@ -237,7 +237,7 @@ memcmp_not_common_alignment (uintptr_t srcp1, uintptr_t srcp2, size_t len)
       goto do2;
     case 0:
       if (OP_T_THRES <= 3 * OPSIZ && len == 0)
-	return 0;
+        return 0;
       a3 = ((op_t *) srcp1)[0];
       a0 = ((op_t *) srcp1)[1];
       b0 = ((op_t *) srcp2)[0];
@@ -251,7 +251,7 @@ memcmp_not_common_alignment (uintptr_t srcp1, uintptr_t srcp2, size_t len)
       srcp2 += 1 * OPSIZ;
       len -= 1;
       if (OP_T_THRES <= 3 * OPSIZ && len == 0)
-	goto do0;
+        goto do0;
       /* Fall through.  */
     }
 
@@ -261,28 +261,28 @@ memcmp_not_common_alignment (uintptr_t srcp1, uintptr_t srcp2, size_t len)
       b0 = ((op_t *) srcp2)[0];
       x = MERGE(a2, shl, a3, shr);
       if (x != b3)
-	return CMP_LT_OR_GT (x, b3);
+        return CMP_LT_OR_GT (x, b3);
 
     do3:
       a1 = ((op_t *) srcp1)[1];
       b1 = ((op_t *) srcp2)[1];
       x = MERGE(a3, shl, a0, shr);
       if (x != b0)
-	return CMP_LT_OR_GT (x, b0);
+        return CMP_LT_OR_GT (x, b0);
 
     do2:
       a2 = ((op_t *) srcp1)[2];
       b2 = ((op_t *) srcp2)[2];
       x = MERGE(a0, shl, a1, shr);
       if (x != b1)
-	return CMP_LT_OR_GT (x, b1);
+        return CMP_LT_OR_GT (x, b1);
 
     do1:
       a3 = ((op_t *) srcp1)[3];
       b3 = ((op_t *) srcp2)[3];
       x = MERGE(a1, shl, a2, shr);
       if (x != b2)
-	return CMP_LT_OR_GT (x, b2);
+        return CMP_LT_OR_GT (x, b2);
 
       srcp1 += 4 * OPSIZ;
       srcp2 += 4 * OPSIZ;
@@ -311,29 +311,29 @@ rpl_memcmp (const void *s1, const void *s2, size_t len)
   if (len >= OP_T_THRES)
     {
       /* There are at least some bytes to compare.  No need to test
-	 for LEN == 0 in this alignment loop.  */
+         for LEN == 0 in this alignment loop.  */
       while (srcp2 % OPSIZ != 0)
-	{
-	  a0 = ((byte *) srcp1)[0];
-	  b0 = ((byte *) srcp2)[0];
-	  srcp1 += 1;
-	  srcp2 += 1;
-	  res = a0 - b0;
-	  if (res != 0)
-	    return res;
-	  len -= 1;
-	}
+        {
+          a0 = ((byte *) srcp1)[0];
+          b0 = ((byte *) srcp2)[0];
+          srcp1 += 1;
+          srcp2 += 1;
+          res = a0 - b0;
+          if (res != 0)
+            return res;
+          len -= 1;
+        }
 
       /* SRCP2 is now aligned for memory operations on `op_t'.
-	 SRCP1 alignment determines if we can do a simple,
-	 aligned compare or need to shuffle bits.  */
+         SRCP1 alignment determines if we can do a simple,
+         aligned compare or need to shuffle bits.  */
 
       if (srcp1 % OPSIZ == 0)
-	res = memcmp_common_alignment (srcp1, srcp2, len / OPSIZ);
+        res = memcmp_common_alignment (srcp1, srcp2, len / OPSIZ);
       else
-	res = memcmp_not_common_alignment (srcp1, srcp2, len / OPSIZ);
+        res = memcmp_not_common_alignment (srcp1, srcp2, len / OPSIZ);
       if (res != 0)
-	return res;
+        return res;
 
       /* Number of bytes remaining in the interval [0..OPSIZ-1].  */
       srcp1 += len & -OPSIZ;
@@ -350,7 +350,7 @@ rpl_memcmp (const void *s1, const void *s2, size_t len)
       srcp2 += 1;
       res = a0 - b0;
       if (res != 0)
-	return res;
+        return res;
       len -= 1;
     }