x86, UML: remove x86-specific implementations of find_first_bit
authorAlexander van Heukelum <heukelum@mailshack.com>
Tue, 1 Apr 2008 15:47:57 +0000 (17:47 +0200)
committerIngo Molnar <mingo@elte.hu>
Sat, 26 Apr 2008 17:21:17 +0000 (19:21 +0200)
x86 has been switched to the generic versions of find_first_bit
and find_first_zero_bit, but the original versions were retained.
This patch just removes the now unused x86-specific versions.

also update UML.

Signed-off-by: Alexander van Heukelum <heukelum@fastmail.fm>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
arch/um/Kconfig.i386
arch/um/Kconfig.x86_64
arch/um/sys-i386/Makefile
arch/um/sys-x86_64/Makefile
arch/x86/lib/Makefile
arch/x86/lib/bitops_64.c [deleted file]
include/asm-x86/bitops_32.h
include/asm-x86/bitops_64.h

index be7556028291c3132b1762d5cc87fc5160ae3768..49990ea422e40127518bcd8e19abcd6a638f8e5a 100644 (file)
@@ -39,6 +39,10 @@ config ARCH_REUSE_HOST_VSYSCALL_AREA
        bool
        default y
 
+config GENERIC_FIND_FIRST_BIT
+       bool
+       default y
+
 config GENERIC_FIND_NEXT_BIT
        bool
        default y
index 4ab5aa62ff3fd054351119338353fa7a06506c14..cc42e59585d2ca2399bcc85e045113b9c03bfabe 100644 (file)
@@ -34,6 +34,10 @@ config SMP_BROKEN
        bool
        default y
 
+config GENERIC_FIND_FIRST_BIT
+       bool
+       default y
+
 config GENERIC_FIND_NEXT_BIT
        bool
        default y
index 964dc1a04c37a7774f56a5d0842d737d477c85c4..598b5c1903af11f10c5c171402b6d283ba9e7565 100644 (file)
@@ -6,7 +6,7 @@ obj-y = bug.o bugs.o checksum.o delay.o fault.o ksyms.o ldt.o ptrace.o \
        ptrace_user.o setjmp.o signal.o stub.o stub_segv.o syscalls.o sysrq.o \
        sys_call_table.o tls.o
 
-subarch-obj-y = lib/bitops_32.o lib/semaphore_32.o lib/string_32.o
+subarch-obj-y = lib/semaphore_32.o lib/string_32.o
 subarch-obj-$(CONFIG_HIGHMEM) += mm/highmem_32.o
 subarch-obj-$(CONFIG_MODULES) += kernel/module_32.o
 
index 3c22de532088b4c5baef1bee93cb85d9cd668840..c8b4cce9cfe1ce333dd877c8644f5b7d4fab3558 100644 (file)
@@ -10,7 +10,7 @@ obj-y = bug.o bugs.o delay.o fault.o ldt.o mem.o ptrace.o ptrace_user.o \
 
 obj-$(CONFIG_MODULES) += um_module.o
 
-subarch-obj-y = lib/bitops_64.o lib/csum-partial_64.o lib/memcpy_64.o lib/thunk_64.o
+subarch-obj-y = lib/csum-partial_64.o lib/memcpy_64.o lib/thunk_64.o
 subarch-obj-$(CONFIG_MODULES) += kernel/module_64.o
 
 ldt-y = ../sys-i386/ldt.o
index 436093299bd3cca58672502e0baae5cf840512d7..76f60f52a885246ff1a8f6ce9bad2c3791d1df94 100644 (file)
@@ -21,7 +21,6 @@ else
 
         lib-y += csum-partial_64.o csum-copy_64.o csum-wrappers_64.o
         lib-y += thunk_64.o clear_page_64.o copy_page_64.o
-        lib-y += bitops_64.o
         lib-y += memmove_64.o memset_64.o
         lib-y += copy_user_64.o rwlock_64.o copy_user_nocache_64.o
 endif
diff --git a/arch/x86/lib/bitops_64.c b/arch/x86/lib/bitops_64.c
deleted file mode 100644 (file)
index 568467d..0000000
+++ /dev/null
@@ -1,109 +0,0 @@
-#ifndef CONFIG_GENERIC_FIND_FIRST_BIT
-#include <linux/bitops.h>
-
-#undef find_first_zero_bit
-#undef find_first_bit
-
-static inline long
-__find_first_zero_bit(const unsigned long * addr, unsigned long size)
-{
-       long d0, d1, d2;
-       long res;
-
-       /*
-        * We must test the size in words, not in bits, because
-        * otherwise incoming sizes in the range -63..-1 will not run
-        * any scasq instructions, and then the flags used by the je
-        * instruction will have whatever random value was in place
-        * before.  Nobody should call us like that, but
-        * find_next_zero_bit() does when offset and size are at the
-        * same word and it fails to find a zero itself.
-        */
-       size += 63;
-       size >>= 6;
-       if (!size)
-               return 0;
-       asm volatile(
-               "  repe; scasq\n"
-               "  je 1f\n"
-               "  xorq -8(%%rdi),%%rax\n"
-               "  subq $8,%%rdi\n"
-               "  bsfq %%rax,%%rdx\n"
-               "1:  subq %[addr],%%rdi\n"
-               "  shlq $3,%%rdi\n"
-               "  addq %%rdi,%%rdx"
-               :"=d" (res), "=&c" (d0), "=&D" (d1), "=&a" (d2)
-               :"0" (0ULL), "1" (size), "2" (addr), "3" (-1ULL),
-                [addr] "S" (addr) : "memory");
-       /*
-        * Any register would do for [addr] above, but GCC tends to
-        * prefer rbx over rsi, even though rsi is readily available
-        * and doesn't have to be saved.
-        */
-       return res;
-}
-
-/**
- * find_first_zero_bit - find the first zero bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit-number of the first zero bit, not the number of the byte
- * containing a bit.
- */
-long find_first_zero_bit(const unsigned long * addr, unsigned long size)
-{
-       return __find_first_zero_bit (addr, size);
-}
-
-static inline long
-__find_first_bit(const unsigned long * addr, unsigned long size)
-{
-       long d0, d1;
-       long res;
-
-       /*
-        * We must test the size in words, not in bits, because
-        * otherwise incoming sizes in the range -63..-1 will not run
-        * any scasq instructions, and then the flags used by the jz
-        * instruction will have whatever random value was in place
-        * before.  Nobody should call us like that, but
-        * find_next_bit() does when offset and size are at the same
-        * word and it fails to find a one itself.
-        */
-       size += 63;
-       size >>= 6;
-       if (!size)
-               return 0;
-       asm volatile(
-               "   repe; scasq\n"
-               "   jz 1f\n"
-               "   subq $8,%%rdi\n"
-               "   bsfq (%%rdi),%%rax\n"
-               "1: subq %[addr],%%rdi\n"
-               "   shlq $3,%%rdi\n"
-               "   addq %%rdi,%%rax"
-               :"=a" (res), "=&c" (d0), "=&D" (d1)
-               :"0" (0ULL), "1" (size), "2" (addr),
-                [addr] "r" (addr) : "memory");
-       return res;
-}
-
-/**
- * find_first_bit - find the first set bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit-number of the first set bit, not the number of the byte
- * containing a bit.
- */
-long find_first_bit(const unsigned long * addr, unsigned long size)
-{
-       return __find_first_bit(addr,size);
-}
-
-#include <linux/module.h>
-
-EXPORT_SYMBOL(find_first_bit);
-EXPORT_SYMBOL(find_first_zero_bit);
-#endif
index ba2c0defafa8c7d3ec8f0adb53b508be660334e0..2e863021bf81e897a05662ccb5a954fc6f1011fe 100644 (file)
@@ -4,64 +4,6 @@
 /*
  * Copyright 1992, Linus Torvalds.
  */
-
-#ifndef CONFIG_GENERIC_FIND_FIRST_BIT
-/**
- * find_first_zero_bit - find the first zero bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit number of the first zero bit, not the number of the byte
- * containing a bit.
- */
-static inline int find_first_zero_bit(const unsigned long *addr, unsigned size)
-{
-       int d0, d1, d2;
-       int res;
-
-       if (!size)
-               return 0;
-       /* This looks at memory.
-        * Mark it volatile to tell gcc not to move it around
-        */
-       asm volatile("movl $-1,%%eax\n\t"
-                    "xorl %%edx,%%edx\n\t"
-                    "repe; scasl\n\t"
-                    "je 1f\n\t"
-                    "xorl -4(%%edi),%%eax\n\t"
-                    "subl $4,%%edi\n\t"
-                    "bsfl %%eax,%%edx\n"
-                    "1:\tsubl %%ebx,%%edi\n\t"
-                    "shll $3,%%edi\n\t"
-                    "addl %%edi,%%edx"
-                    : "=d" (res), "=&c" (d0), "=&D" (d1), "=&a" (d2)
-                    : "1" ((size + 31) >> 5), "2" (addr),
-                      "b" (addr) : "memory");
-       return res;
-}
-
-/**
- * find_first_bit - find the first set bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit number of the first set bit, not the number of the byte
- * containing a bit.
- */
-static inline unsigned find_first_bit(const unsigned long *addr, unsigned size)
-{
-       unsigned x = 0;
-
-       while (x < size) {
-               unsigned long val = *addr++;
-               if (val)
-                       return __ffs(val) + x;
-               x += sizeof(*addr) << 3;
-       }
-       return x;
-}
-#endif
-
 #ifdef __KERNEL__
 
 #include <asm-generic/bitops/sched.h>
index 4081d7ecc2bddf3804244488e962b558ed3837df..cb23122d23f1b091e02fb0fd057c7e6339bb69a1 100644 (file)
@@ -4,29 +4,6 @@
 /*
  * Copyright 1992, Linus Torvalds.
  */
-
-#ifndef CONFIG_GENERIC_FIND_FIRST_BIT
-extern long find_first_zero_bit(const unsigned long *addr, unsigned long size);
-extern long find_first_bit(const unsigned long *addr, unsigned long size);
-
-/* return index of first bet set in val or max when no bit is set */
-static inline long __scanbit(unsigned long val, unsigned long max)
-{
-       asm("bsfq %1,%0 ; cmovz %2,%0" : "=&r" (val) : "r" (val), "r" (max));
-       return val;
-}
-
-#define find_first_bit(addr, size)                                     \
-       ((__builtin_constant_p((size)) && (size) <= BITS_PER_LONG       \
-         ? (__scanbit(*(unsigned long *)(addr), (size)))               \
-         : find_first_bit((addr), (size))))
-
-#define find_first_zero_bit(addr, size)                                        \
-       ((__builtin_constant_p((size)) && (size) <= BITS_PER_LONG       \
-         ? (__scanbit(~*(unsigned long *)(addr), (size)))              \
-         : find_first_zero_bit((addr), (size))))
-#endif
-
 static inline void set_bit_string(unsigned long *bitmap, unsigned long i,
                                  int len)
 {