arch/tile: support building big-endian kernel

The toolchain supports big-endian mode now, so add support for building
the kernel to run big-endian as well.

Signed-off-by: Chris Metcalf <cmetcalf@tilera.com>

5 files changed, 66 insertions, 24 deletions

diff --git a/arch/tile/lib/memchr_64.c b/arch/tile/lib/memchr_64.c
index 84fdc8d8e735..6f867dbf7c56 100644
--- a/arch/tile/lib/memchr_64.c
+++ b/arch/tile/lib/memchr_64.c
@@ -15,6 +15,7 @@
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/module.h>
+#include "string-endian.h"
 
 void *memchr(const void *s, int c, size_t n)
 {
@@ -39,11 +40,8 @@ void *memchr(const void *s, int c, size_t n)
 
         /* Read the first word, but munge it so that bytes before the array
          * will not match goal.
-         *
-         * Note that this shift count expression works because we know
-         * shift counts are taken mod 64.
          */
-        before_mask = (1ULL << (s_int << 3)) - 1;
+        before_mask = MASK(s_int);
         v = (*p | before_mask) ^ (goal & before_mask);
 
         /* Compute the address of the last byte. */
@@ -65,7 +63,7 @@ void *memchr(const void *s, int c, size_t n)
         /* We found a match, but it might be in a byte past the end
          * of the array.
          */
-        ret = ((char *)p) + (__insn_ctz(bits) >> 3);
+        ret = ((char *)p) + (CFZ(bits) >> 3);
         return (ret <= last_byte_ptr) ? ret : NULL;
 }
 EXPORT_SYMBOL(memchr);
diff --git a/arch/tile/lib/memcpy_64.c b/arch/tile/lib/memcpy_64.c
index 3fab9a6a2bbe..c79b8e7c6828 100644
--- a/arch/tile/lib/memcpy_64.c
+++ b/arch/tile/lib/memcpy_64.c
@@ -15,7 +15,6 @@
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/module.h>
-#define __memcpy memcpy
 /* EXPORT_SYMBOL() is in arch/tile/lib/exports.c since this should be asm. */
 
 /* Must be 8 bytes in size. */
@@ -188,6 +187,7 @@ int USERCOPY_FUNC(void *__restrict dstv, const void *__restrict srcv, size_t n)
 
         /* n != 0 if we get here.  Write out any trailing bytes. */
         dst1 = (char *)dst8;
+#ifndef __BIG_ENDIAN__
         if (n & 4) {
                 ST4((uint32_t *)dst1, final);
                 dst1 += 4;
@@ -202,11 +202,30 @@ int USERCOPY_FUNC(void *__restrict dstv, const void *__restrict srcv, size_t n)
         }
         if (n)
                 ST1((uint8_t *)dst1, final);
+#else
+        if (n & 4) {
+                ST4((uint32_t *)dst1, final >> 32);
+                dst1 += 4;
+        }
+        else
+        {
+                final >>= 32;
+        }
+        if (n & 2) {
+                ST2((uint16_t *)dst1, final >> 16);
+                dst1 += 2;
+        }
+        else
+        {
+                final >>= 16;
+        }
+        if (n & 1)
+                ST1((uint8_t *)dst1, final >> 8);
+#endif
 
         return RETVAL;
 }
 
-
 #ifdef USERCOPY_FUNC
 #undef ST1
 #undef ST2
diff --git a/arch/tile/lib/strchr_64.c b/arch/tile/lib/strchr_64.c
index 617a9273aaa8..f39f9dc422b0 100644
--- a/arch/tile/lib/strchr_64.c
+++ b/arch/tile/lib/strchr_64.c
@@ -15,8 +15,7 @@
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/module.h>
-
-#undef strchr
+#include "string-endian.h"
 
 char *strchr(const char *s, int c)
 {
@@ -33,13 +32,9 @@ char *strchr(const char *s, int c)
          * match neither zero nor goal (we make sure the high bit of each
          * byte is 1, and the low 7 bits are all the opposite of the goal
          * byte).
-         *
-         * Note that this shift count expression works because we know shift
-         * counts are taken mod 64.
          */
-        const uint64_t before_mask = (1ULL << (s_int << 3)) - 1;
-        uint64_t v = (*p | before_mask) ^
-                (goal & __insn_v1shrsi(before_mask, 1));
+        const uint64_t before_mask = MASK(s_int);
+        uint64_t v = (*p | before_mask) ^ (goal & __insn_v1shrui(before_mask, 1));
 
         uint64_t zero_matches, goal_matches;
         while (1) {
@@ -55,8 +50,8 @@ char *strchr(const char *s, int c)
                 v = *++p;
         }
 
-        z = __insn_ctz(zero_matches);
-        g = __insn_ctz(goal_matches);
+        z = CFZ(zero_matches);
+        g = CFZ(goal_matches);
 
         /* If we found c before '\0' we got a match. Note that if c == '\0'
          * then g == z, and we correctly return the address of the '\0'
diff --git a/arch/tile/lib/string-endian.h b/arch/tile/lib/string-endian.h
new file mode 100644
index 000000000000..c0eed7ce69c3
--- /dev/null
+++ b/arch/tile/lib/string-endian.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2011 Tilera Corporation. All Rights Reserved.
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation, version 2.
+ *
+ *   This program is distributed in the hope that it will be useful, but
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ *   NON INFRINGEMENT.  See the GNU General Public License for
+ *   more details.
+ *
+ * Provide a mask based on the pointer alignment that
+ * sets up non-zero bytes before the beginning of the string.
+ * The MASK expression works because shift counts are taken mod 64.
+ * Also, specify how to count "first" and "last" bits
+ * when the bits have been read as a word.
+ */
+
+#include <asm/byteorder.h>
+
+#ifdef __LITTLE_ENDIAN
+#define MASK(x) (__insn_shl(1ULL, (x << 3)) - 1)
+#define NULMASK(x) ((2ULL << x) - 1)
+#define CFZ(x) __insn_ctz(x)
+#define REVCZ(x) __insn_clz(x)
+#else
+#define MASK(x) (__insn_shl(-2LL, ((-x << 3) - 1)))
+#define NULMASK(x) (-2LL << (63 - x))
+#define CFZ(x) __insn_clz(x)
+#define REVCZ(x) __insn_ctz(x)
+#endif
diff --git a/arch/tile/lib/strlen_64.c b/arch/tile/lib/strlen_64.c
index 1c92d46202a8..9583fc3361fa 100644
--- a/arch/tile/lib/strlen_64.c
+++ b/arch/tile/lib/strlen_64.c
@@ -15,8 +15,7 @@
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/module.h>
-
-#undef strlen
+#include "string-endian.h"
 
 size_t strlen(const char *s)
 {
@@ -24,15 +23,13 @@ size_t strlen(const char *s)
         const uintptr_t s_int = (uintptr_t) s;
         const uint64_t *p = (const uint64_t *)(s_int & -8);
 
-        /* Read the first word, but force bytes before the string to be nonzero.
-         * This expression works because we know shift counts are taken mod 64.
-         */
-        uint64_t v = *p | ((1ULL << (s_int << 3)) - 1);
+        /* Read and MASK the first word. */
+        uint64_t v = *p | MASK(s_int);
 
         uint64_t bits;
         while ((bits = __insn_v1cmpeqi(v, 0)) == 0)
                 v = *++p;
 
-        return ((const char *)p) + (__insn_ctz(bits) >> 3) - s;
+        return ((const char *)p) + (CFZ(bits) >> 3) - s;
 }
 EXPORT_SYMBOL(strlen);