text: #ifndef __M68K_UACCESS_H
  #define __M68K_UACCESS_H
  
  /*
   * User space memory access functions
   */
  #include <linux/sched.h>
  #include <asm/segment.h>
  
  #define VERIFY_READ	0
  #define VERIFY_WRITE	1
  
  /* We let the MMU do all checking */
  #define access_ok(type,addr,size) 1
  
  static inline int verify_area(int type, const void *addr, unsigned long size)
  {
  	return access_ok(type,addr,size)?0:-EFAULT;
  }
  
  /*
   * The exception table consists of pairs of addresses: the first is the
   * address of an instruction that is allowed to fault, and the second is
   * the address at which the program should continue.  No registers are
   * modified, so it is entirely up to the continuation code to figure out
   * what to do.
   *
   * All the routines below use bits of fixup code that are out of line
   * with the main instruction path.  This means when everything is well,
   * we don't even have to jump over them.  Further, they do not intrude
   * on our cache or tlb entries.
   */
  
  struct exception_table_entry
  {
  	unsigned long insn, fixup;
  };
  
  /* Returns 0 if exception not found and fixup otherwise.  */
  extern unsigned long search_exception_table(unsigned long);
  
  
  /*
   * These are the main single-value transfer routines.  They automatically
   * use the right size if we just have the right pointer type.
   */
  
  #define put_user(x, ptr)				\
  ({							\
      int __pu_err;					\
      typeof(*(ptr)) __pu_val = (x);			\
      switch (sizeof (*(ptr))) {				\
      case 1:						\
  	__put_user_asm(__pu_err, __pu_val, ptr, b);	\
  	break;						\
      case 2:						\
  	__put_user_asm(__pu_err, __pu_val, ptr, w);	\
  	break;						\
      case 4:						\
  	__put_user_asm(__pu_err, __pu_val, ptr, l);	\
  	break;						\
      case 8:                                             \
         __pu_err = __constant_copy_to_user(ptr, &__pu_val, 8);        \
         break;                                           \
      default:						\
  	__pu_err = __put_user_bad();			\
  	break;						\
      }							\
      __pu_err;						\
  })
  #define __put_user(x, ptr) put_user(x, ptr)
  
  extern int __put_user_bad(void);
  
  /*
   * Tell gcc we read from memory instead of writing: this is because
   * we do not write to any memory gcc knows about, so there are no
   * aliasing issues.
   */
  #define __put_user_asm(err,x,ptr,bwl)			\
  __asm__ __volatile__					\
      ("21:moves" #bwl " %2,%1\n"				\
       "1:\n"						\
       ".section .fixup,\"ax\"\n"				\
       "   .even\n"					\
       "2: movel %3,%0\n"					\
       "   jra 1b\n"					\
       ".previous\n"					\
       ".section __ex_table,\"a\"\n"			\
       "   .align 4\n"					\
       "   .long 21b,2b\n"				\
       "   .long 1b,2b\n"					\
       ".previous"					\
       : "=d"(err)					\
       : "m"(*(ptr)), "r"(x), "i"(-EFAULT), "0"(0))
  
  #define get_user(x, ptr)					\
  ({								\
      int __gu_err;						\
      typeof(*(ptr)) __gu_val;					\
      switch (sizeof(*(ptr))) {					\
      case 1:							\
  	__get_user_asm(__gu_err, __gu_val, ptr, b, "=d");	\
  	break;							\
      case 2:							\
  	__get_user_asm(__gu_err, __gu_val, ptr, w, "=r");	\
  	break;							\
      case 4:							\
  	__get_user_asm(__gu_err, __gu_val, ptr, l, "=r");	\
  	break;							\
      case 8:                                                     \
          __gu_err = __constant_copy_from_user(&__gu_val, ptr, 8);  \
          break;                                                  \
      default:							\
  	__gu_val = 0;						\
  	__gu_err = __get_user_bad();				\
  	break;							\
      }								\
      (x) = __gu_val;						\
      __gu_err;							\
  })
  #define __get_user(x, ptr) get_user(x, ptr)
  
  extern int __get_user_bad(void);
  
  #define __get_user_asm(err,x,ptr,bwl,reg)	\
  __asm__ __volatile__				\
      ("1: moves" #bwl " %2,%1\n"			\
       "2:\n"					\
       ".section .fixup,\"ax\"\n"			\
       "   .even\n"				\
       "3: movel %3,%0\n"				\
       "   sub" #bwl " %1,%1\n"			\
       "   jra 2b\n"				\
       ".previous\n"				\
       ".section __ex_table,\"a\"\n"		\
       "   .align 4\n"				\
       "   .long 1b,3b\n"				\
       ".previous"				\
       : "=d"(err), reg(x)			\
       : "m"(*(ptr)), "i" (-EFAULT), "0"(0))
  
  static inline unsigned long
  __generic_copy_from_user(void *to, const void *from, unsigned long n)
  {
      unsigned long tmp;
      __asm__ __volatile__
  	("   tstl %2\n"
  	 "   jeq 2f\n"
  	 "1: movesl (%1)+,%3\n"
  	 "   movel %3,(%0)+\n"
  	 "   subql #1,%2\n"
  	 "   jne 1b\n"
  	 "2: movel %4,%2\n"
  	 "   bclr #1,%2\n"
  	 "   jeq 4f\n"
  	 "3: movesw (%1)+,%3\n"
  	 "   movew %3,(%0)+\n"
  	 "4: bclr #0,%2\n"
  	 "   jeq 6f\n"
  	 "5: movesb (%1)+,%3\n"
  	 "   moveb %3,(%0)+\n"
  	 "6:\n"
  	 ".section .fixup,\"ax\"\n"
  	 "   .even\n"
  	 "7: movel %2,%%d0\n"
  	 "71:clrl (%0)+\n"
  	 "   subql #1,%%d0\n"
  	 "   jne 71b\n"
  	 "   lsll #2,%2\n"
  	 "   addl %4,%2\n"
  	 "   btst #1,%4\n"
  	 "   jne 81f\n"
  	 "   btst #0,%4\n"
  	 "   jne 91f\n"
  	 "   jra 6b\n"
  	 "8: addql #2,%2\n"
  	 "81:clrw (%0)+\n"
  	 "   btst #0,%4\n"
  	 "   jne 91f\n"
  	 "   jra 6b\n"
  	 "9: addql #1,%2\n"
  	 "91:clrb (%0)+\n"
  	 "   jra 6b\n"
           ".previous\n"
  	 ".section __ex_table,\"a\"\n"
  	 "   .align 4\n"
  	 "   .long 1b,7b\n"
  	 "   .long 3b,8b\n"
  	 "   .long 5b,9b\n"
  	 ".previous"
  	 : "=a"(to), "=a"(from), "=d"(n), "=&d"(tmp)
  	 : "d"(n & 3), "0"(to), "1"(from), "2"(n/4)
  	 : "d0", "memory");
      return n;
  }
  
  static inline unsigned long
  __generic_copy_to_user(void *to, const void *from, unsigned long n)
  {
      unsigned long tmp;
      __asm__ __volatile__
  	("   tstl %2\n"
  	 "   jeq 3f\n"
  	 "1: movel (%1)+,%3\n"
  	 "22:movesl %3,(%0)+\n"
  	 "2: subql #1,%2\n"
  	 "   jne 1b\n"
  	 "3: movel %4,%2\n"
  	 "   bclr #1,%2\n"
  	 "   jeq 4f\n"
  	 "   movew (%1)+,%3\n"
  	 "24:movesw %3,(%0)+\n"
  	 "4: bclr #0,%2\n"
  	 "   jeq 5f\n"
  	 "   moveb (%1)+,%3\n"
  	 "25:movesb %3,(%0)+\n"
  	 "5:\n"
  	 ".section .fixup,\"ax\"\n"
  	 "   .even\n"
  	 "60:addql #1,%2\n"
  	 "6: lsll #2,%2\n"
  	 "   addl %4,%2\n"
  	 "   jra 5b\n"
  	 "7: addql #2,%2\n"
  	 "   jra 5b\n"
  	 "8: addql #1,%2\n"
  	 "   jra 5b\n"
  	 ".previous\n"
  	 ".section __ex_table,\"a\"\n"
  	 "   .align 4\n"
  	 "   .long 1b,60b\n"
  	 "   .long 22b,6b\n"
  	 "   .long 2b,6b\n"
  	 "   .long 24b,7b\n"
  	 "   .long 3b,60b\n"
  	 "   .long 4b,7b\n"
  	 "   .long 25b,8b\n"
  	 "   .long 5b,8b\n"
  	 ".previous"
  	 : "=a"(to), "=a"(from), "=d"(n), "=&d"(tmp)
  	 : "r"(n & 3), "0"(to), "1"(from), "2"(n / 4)
  	 : "memory");
      return n;
  }
  
  #define __copy_from_user_big(to, from, n, fixup, copy)	\
      __asm__ __volatile__				\
  	("10: movesl (%1)+,%%d0\n"			\
  	 "    movel %%d0,(%0)+\n"			\
  	 "    subql #1,%2\n"				\
  	 "    jne 10b\n"				\
  	 ".section .fixup,\"ax\"\n"			\
  	 "    .even\n"					\
  	 "11: movel %2,%%d0\n"				\
  	 "13: clrl (%0)+\n"				\
  	 "    subql #1,%%d0\n"				\
  	 "    jne 13b\n"				\
  	 "    lsll #2,%2\n"				\
  	 fixup "\n"					\
  	 "    jra 12f\n"				\
  	 ".previous\n"					\
  	 ".section __ex_table,\"a\"\n"			\
  	 "    .align 4\n"				\
  	 "    .long 10b,11b\n"				\
  	 ".previous\n"					\
  	 copy "\n"					\
  	 "12:"						\
  	 : "=a"(to), "=a"(from), "=d"(n)		\
  	 : "0"(to), "1"(from), "2"(n/4)			\
  	 : "d0", "memory")
  
  static inline unsigned long
  __constant_copy_from_user(void *to, const void *from, unsigned long n)
  {
      switch (n) {
      case 0:
  	break;
      case 1:
  	__asm__ __volatile__
  	    ("1: movesb (%1)+,%%d0\n"
  	     "   moveb %%d0,(%0)+\n"
  	     "2:\n"
  	     ".section .fixup,\"ax\"\n"
  	     "   .even\n"
  	     "3: addql #1,%2\n"
  	     "   clrb (%0)+\n"
  	     "   jra 2b\n"
  	     ".previous\n"
  	     ".section __ex_table,\"a\"\n"
  	     "   .align 4\n"
  	     "   .long 1b,3b\n"
  	     ".previous"
  	     : "=a"(to), "=a"(from), "=d"(n)
  	     : "0"(to), "1"(from), "2"(0)
  	     : "d0", "memory");
  	break;
      case 2:
  	__asm__ __volatile__
  	    ("1: movesw (%1)+,%%d0\n"
  	     "   movew %%d0,(%0)+\n"
  	     "2:\n"
  	     ".section .fixup,\"ax\"\n"
  	     "   .even\n"
  	     "3: addql #2,%2\n"
  	     "   clrw (%0)+\n"
  	     "   jra 2b\n"
  	     ".previous\n"
  	     ".section __ex_table,\"a\"\n"
  	     "   .align 4\n"
  	     "   .long 1b,3b\n"
  	     ".previous"
  	     : "=a"(to), "=a"(from), "=d"(n)
  	     : "0"(to), "1"(from), "2"(0)
  	     : "d0", "memory");
  	break;
      case 3:
  	__asm__ __volatile__
  	    ("1: movesw (%1)+,%%d0\n"
  	     "   movew %%d0,(%0)+\n"
  	     "2: movesb (%1)+,%%d0\n"
  	     "   moveb %%d0,(%0)+\n"
  	     "3:"
  	     ".section .fixup,\"ax\"\n"
  	     "   .even\n"
  	     "4: addql #2,%2\n"
  	     "   clrw (%0)+\n"
  	     "5: addql #1,%2\n"
  	     "   clrb (%0)+\n"
  	     "   jra 3b\n"
  	     ".previous\n"
  	     ".section __ex_table,\"a\"\n"
  	     "   .align 4\n"
  	     "   .long 1b,4b\n"
  	     "   .long 2b,5b\n"
  	     ".previous"
  	     : "=a"(to), "=a"(from), "=d"(n)
  	     : "0"(to), "1"(from), "2"(0)
  	     : "d0", "memory");
  	break;
      case 4:
  	__asm__ __volatile__
  	    ("1: movesl (%1)+,%%d0\n"
  	     "   movel %%d0,(%0)+\n"
  	     "2:"
  	     ".section .fixup,\"ax\"\n"
  	     "   .even\n"
  	     "3: addql #4,%2\n"
  	     "   clrl (%0)+\n"
  	     "   jra 2b\n"
  	     ".previous\n"
  	     ".section __ex_table,\"a\"\n"
  	     "   .align 4\n"
  	     "   .long 1b,3b\n"
  	     ".previous"
  	     : "=a"(to), "=a"(from), "=d"(n)
  	     : "0"(to), "1"(from), "2"(0)
  	     : "d0", "memory");
  	break;
      case 8:
  	__asm__ __volatile__
  	    ("1: movesl (%1)+,%%d0\n"
  	     "   movel %%d0,(%0)+\n"
  	     "2: movesl (%1)+,%%d0\n"
  	     "   movel %%d0,(%0)+\n"
  	     "3:"
  	     ".section .fixup,\"ax\"\n"
  	     "   .even\n"
  	     "4: addql #4,%2\n"
  	     "   clrl (%0)+\n"
  	     "5: addql #4,%2\n"
  	     "   clrl (%0)+\n"
  	     "   jra 3b\n"
  	     ".previous\n"
  	     ".section __ex_table,\"a\"\n"
  	     "   .align 4\n"
  	     "   .long 1b,4b\n"
  	     "   .long 2b,5b\n"
  	     ".previous"
  	     : "=a"(to), "=a"(from), "=d"(n)
  	     : "0"(to), "1"(from), "2"(0)
  	     : "d0", "memory");
  	break;
      case 12:
  	__asm__ __volatile__
  	    ("1: movesl (%1)+,%%d0\n"
  	     "   movel %%d0,(%0)+\n"
  	     "2: movesl (%1)+,%%d0\n"
  	     "   movel %%d0,(%0)+\n"
  	     "3: movesl (%1)+,%%d0\n"
  	     "   movel %%d0,(%0)+\n"
  	     "4:"
  	     ".section .fixup,\"ax\"\n"
  	     "   .even\n"
  	     "5: addql #4,%2\n"
  	     "   clrl (%0)+\n"
  	     "6: addql #4,%2\n"
  	     "   clrl (%0)+\n"
  	     "7: addql #4,%2\n"
  	     "   clrl (%0)+\n"
  	     "   jra 4b\n"
  	     ".previous\n"
  	     ".section __ex_table,\"a\"\n"
  	     "   .align 4\n"
  	     "   .long 1b,5b\n"
  	     "   .long 2b,6b\n"
  	     "   .long 3b,7b\n"
  	     ".previous"
  	     : "=a"(to), "=a"(from), "=d"(n)
  	     : "0"(to), "1"(from), "2"(0)
  	     : "d0", "memory");
  	break;
      case 16:
  	__asm__ __volatile__
  	    ("1: movesl (%1)+,%%d0\n"
  	     "   movel %%d0,(%0)+\n"
  	     "2: movesl (%1)+,%%d0\n"
  	     "   movel %%d0,(%0)+\n"
  	     "3: movesl (%1)+,%%d0\n"
  	     "   movel %%d0,(%0)+\n"
  	     "4: movesl (%1)+,%%d0\n"
  	     "   movel %%d0,(%0)+\n"
  	     "5:"
  	     ".section .fixup,\"ax\"\n"
  	     "   .even\n"
  	     "6: addql #4,%2\n"
  	     "   clrl (%0)+\n"
  	     "7: addql #4,%2\n"
  	     "   clrl (%0)+\n"
  	     "8: addql #4,%2\n"
  	     "   clrl (%0)+\n"
  	     "9: addql #4,%2\n"
  	     "   clrl (%0)+\n"
  	     "   jra 5b\n"
  	     ".previous\n"
  	     ".section __ex_table,\"a\"\n"
  	     "   .align 4\n"
  	     "   .long 1b,6b\n"
  	     "   .long 2b,7b\n"
  	     "   .long 3b,8b\n"
  	     "   .long 4b,9b\n"
  	     ".previous"
  	     : "=a"(to), "=a"(from), "=d"(n)
  	     : "0"(to), "1"(from), "2"(0)
  	     : "d0", "memory");
  	break;
      default:
  	switch (n & 3) {
  	case 0:
  	    __copy_from_user_big(to, from, n, "", "");
  	    break;
  	case 1:
  	    __copy_from_user_big(to, from, n,
  				 /* fixup */
  				 "1: addql #1,%2\n"
  				 "   clrb (%0)+",
  				 /* copy */
  				 "2: movesb (%1)+,%%d0\n"
  				 "   moveb %%d0,(%0)+\n"
  				 ".section __ex_table,\"a\"\n"
  				 "   .long 2b,1b\n"
  				 ".previous");
  	    break;
  	case 2:
  	    __copy_from_user_big(to, from, n,
  				 /* fixup */
  				 "1: addql #2,%2\n"
  				 "   clrw (%0)+",
  				 /* copy */
  				 "2: movesw (%1)+,%%d0\n"
  				 "   movew %%d0,(%0)+\n"
  				 ".section __ex_table,\"a\"\n"
  				 "   .long 2b,1b\n"
  				 ".previous");
  	    break;
  	case 3:
  	    __copy_from_user_big(to, from, n,
  				 /* fixup */
  				 "1: addql #2,%2\n"
  				 "   clrw (%0)+\n"
  				 "2: addql #1,%2\n"
  				 "   clrb (%0)+",
  				 /* copy */
  				 "3: movesw (%1)+,%%d0\n"
  				 "   movew %%d0,(%0)+\n"
  				 "4: movesb (%1)+,%%d0\n"
  				 "   moveb %%d0,(%0)+\n"
  				 ".section __ex_table,\"a\"\n"
  				 "   .long 3b,1b\n"
  				 "   .long 4b,2b\n"
  				 ".previous");
  	    break;
  	}
  	break;
      }
      return n;
  }
  
  #define __copy_to_user_big(to, from, n, fixup, copy)	\
      __asm__ __volatile__				\
  	("10: movel (%1)+,%%d0\n"			\
  	 "31: movesl %%d0,(%0)+\n"			\
  	 "11: subql #1,%2\n"				\
  	 "    jne 10b\n"				\
  	 "41:\n"					\
  	 ".section .fixup,\"ax\"\n"			\
  	 "   .even\n"					\
  	 "22: addql #1,%2\n"				\
  	 "12: lsll #2,%2\n"				\
  	 fixup "\n"					\
  	 "    jra 13f\n"				\
  	 ".previous\n"					\
  	 ".section __ex_table,\"a\"\n"			\
  	 "    .align 4\n"				\
  	 "    .long 10b,22b\n"				\
  	 "    .long 31b,12b\n"				\
  	 "    .long 11b,12b\n"				\
  	 "    .long 41b,22b\n"				\
  	 ".previous\n"					\
  	 copy "\n"					\
  	 "13:"						\
  	 : "=a"(to), "=a"(from), "=d"(n)		\
  	 : "0"(to), "1"(from), "2"(n/4)			\
  	 : "d0", "memory")
  
  static inline unsigned long
  __constant_copy_to_user(void *to, const void *from, unsigned long n)
  {
      switch (n) {
      case 0:
  	break;
      case 1:
  	__asm__ __volatile__
  	    ("   moveb (%1)+,%%d0\n"
  	     "21:movesb %%d0,(%0)+\n"
  	     "1:\n"
  	     ".section .fixup,\"ax\"\n"
  	     "   .even\n"
  	     "2: addql #1,%2\n"
  	     "   jra 1b\n"
  	     ".previous\n"
  	     ".section __ex_table,\"a\"\n"
  	     "   .align 4\n  "
  	     "   .long 21b,2b\n"
  	     "   .long 1b,2b\n"
  	     ".previous"
  	     : "=a"(to), "=a"(from), "=d"(n)
  	     : "0"(to), "1"(from), "2"(0)
  	     : "d0", "memory");
  	break;
      case 2:
  	__asm__ __volatile__
  	    ("   movew (%1)+,%%d0\n"
  	     "21:movesw %%d0,(%0)+\n"
  	     "1:\n"
  	     ".section .fixup,\"ax\"\n"
  	     "   .even\n"
  	     "2: addql #2,%2\n"
  	     "   jra 1b\n"
  	     ".previous\n"
  	     ".section __ex_table,\"a\"\n"
  	     "   .align 4\n"
  	     "   .long 21b,2b\n"
  	     "   .long 1b,2b\n"
  	     ".previous"
  	     : "=a"(to), "=a"(from), "=d"(n)
  	     : "0"(to), "1"(from), "2"(0)
  	     : "d0", "memory");
  	break;
      case 3:
  	__asm__ __volatile__
  	    ("   movew (%1)+,%%d0\n"
  	     "21:movesw %%d0,(%0)+\n"
  	     "1: moveb (%1)+,%%d0\n"
  	     "22:movesb %%d0,(%0)+\n"
  	     "2:\n"
  	     ".section .fixup,\"ax\"\n"
  	     "   .even\n"
  	     "3: addql #2,%2\n"
  	     "4: addql #1,%2\n"
  	     "   jra 2b\n"
  	     ".previous\n"
  	     ".section __ex_table,\"a\"\n"
  	     "   .align 4\n"
  	     "   .long 21b,3b\n"
  	     "   .long 1b,3b\n"
  	     "   .long 22b,4b\n"
  	     "   .long 2b,4b\n"
  	     ".previous"
  	     : "=a"(to), "=a"(from), "=d"(n)
  	     : "0"(to), "1"(from), "2"(0)
  	     : "d0", "memory");
  	break;
      case 4:
  	__asm__ __volatile__
  	    ("   movel (%1)+,%%d0\n"
  	     "21:movesl %%d0,(%0)+\n"
  	     "1:\n"
  	     ".section .fixup,\"ax\"\n"
  	     "   .even\n"
  	     "2: addql #4,%2\n"
  	     "   jra 1b\n"
  	     ".previous\n"
  	     ".section __ex_table,\"a\"\n"
  	     "   .align 4\n"
  	     "   .long 21b,2b\n"
  	     "   .long 1b,2b\n"
  	     ".previous"
  	     : "=a"(to), "=a"(from), "=d"(n)
  	     : "0"(to), "1"(from), "2"(0)
  	     : "d0", "memory");
  	break;
      case 8:
  	__asm__ __volatile__
  	    ("   movel (%1)+,%%d0\n"
  	     "21:movesl %%d0,(%0)+\n"
  	     "1: movel (%1)+,%%d0\n"
  	     "22:movesl %%d0,(%0)+\n"
  	     "2:\n"
  	     ".section .fixup,\"ax\"\n"
  	     "   .even\n"
  	     "3: addql #4,%2\n"
  	     "4: addql #4,%2\n"
  	     "   jra 2b\n"
  	     ".previous\n"
  	     ".section __ex_table,\"a\"\n"
  	     "   .align 4\n"
  	     "   .long 21b,3b\n"
  	     "   .long 1b,3b\n"
  	     "   .long 22b,4b\n"
  	     "   .long 2b,4b\n"
  	     ".previous"
  	     : "=a"(to), "=a"(from), "=d"(n)
  	     : "0"(to), "1"(from), "2"(0)
  	     : "d0", "memory");
  	break;
      case 12:
  	__asm__ __volatile__
  	    ("   movel (%1)+,%%d0\n"
  	     "21:movesl %%d0,(%0)+\n"
  	     "1: movel (%1)+,%%d0\n"
  	     "22:movesl %%d0,(%0)+\n"
  	     "2: movel (%1)+,%%d0\n"
  	     "23:movesl %%d0,(%0)+\n"
  	     "3:\n"
  	     ".section .fixup,\"ax\"\n"
  	     "   .even\n"
  	     "4: addql #4,%2\n"
  	     "5: addql #4,%2\n"
  	     "6: addql #4,%2\n"
  	     "   jra 3b\n"
  	     ".previous\n"
  	     ".section __ex_table,\"a\"\n"
  	     "   .align 4\n"
  	     "   .long 21b,4b\n"
  	     "   .long 1b,4b\n"
  	     "   .long 22b,5b\n"
  	     "   .long 2b,5b\n"
  	     "   .long 23b,6b\n"
  	     "   .long 3b,6b\n"
  	     ".previous"
  	     : "=a"(to), "=a"(from), "=d"(n)
  	     : "0"(to), "1"(from), "2"(0)
  	     : "d0", "memory");
  	break;
      case 16:
  	__asm__ __volatile__
  	    ("   movel (%1)+,%%d0\n"
  	     "21:movesl %%d0,(%0)+\n"
  	     "1: movel (%1)+,%%d0\n"
  	     "22:movesl %%d0,(%0)+\n"
  	     "2: movel (%1)+,%%d0\n"
  	     "23:movesl %%d0,(%0)+\n"
  	     "3: movel (%1)+,%%d0\n"
  	     "24:movesl %%d0,(%0)+\n"
  	     "4:"
  	     ".section .fixup,\"ax\"\n"
  	     "   .even\n"
  	     "5: addql #4,%2\n"
  	     "6: addql #4,%2\n"
  	     "7: addql #4,%2\n"
  	     "8: addql #4,%2\n"
  	     "   jra 4b\n"
  	     ".previous\n"
  	     ".section __ex_table,\"a\"\n"
  	     "   .align 4\n"
  	     "   .long 21b,5b\n"
  	     "   .long 1b,5b\n"
  	     "   .long 22b,6b\n"
  	     "   .long 2b,6b\n"
  	     "   .long 23b,7b\n"
  	     "   .long 3b,7b\n"
  	     "   .long 24b,8b\n"
  	     "   .long 4b,8b\n"
  	     ".previous"
  	     : "=a"(to), "=a"(from), "=d"(n)
  	     : "0"(to), "1"(from), "2"(0)
  	     : "d0", "memory");
  	break;
      default:
  	switch (n & 3) {
  	case 0:
  	    __copy_to_user_big(to, from, n, "", "");
  	    break;
  	case 1:
  	    __copy_to_user_big(to, from, n,
  			       /* fixup */
  			       "1: addql #1,%2",
  			       /* copy */
  			       "   moveb (%1)+,%%d0\n"
  			       "22:movesb %%d0,(%0)+\n"
  			       "2:"
  			       ".section __ex_table,\"a\"\n"
  			       "   .long 22b,1b\n"
  			       "   .long 2b,1b\n"
  			       ".previous");
  	    break;
  	case 2:
  	    __copy_to_user_big(to, from, n,
  			       /* fixup */
  			       "1: addql #2,%2",
  			       /* copy */
  			       "   movew (%1)+,%%d0\n"
  			       "22:movesw %%d0,(%0)+\n"
  			       "2:"
  			       ".section __ex_table,\"a\"\n"
  			       "   .long 22b,1b\n"
  			       "   .long 2b,1b\n"
  			       ".previous");
  	    break;
  	case 3:
  	    __copy_to_user_big(to, from, n,
  			       /* fixup */
  			       "1: addql #2,%2\n"
  			       "2: addql #1,%2",
  			       /* copy */
  			       "   movew (%1)+,%%d0\n"
  			       "23:movesw %%d0,(%0)+\n"
  			       "3: moveb (%1)+,%%d0\n"
  			       "24:movesb %%d0,(%0)+\n"
  			       "4:"
  			       ".section __ex_table,\"a\"\n"
  			       "   .long 23b,1b\n"
  			       "   .long 3b,1b\n"
  			       "   .long 24b,2b\n"
  			       "   .long 4b,2b\n"
  			       ".previous");
  	    break;
  	}
  	break;
      }
      return n;
  }
  
  #define copy_from_user(to, from, n)		\
  (__builtin_constant_p(n) ?			\
   __constant_copy_from_user(to, from, n) :	\
   __generic_copy_from_user(to, from, n))
  
  #define copy_to_user(to, from, n)		\
  (__builtin_constant_p(n) ?			\
   __constant_copy_to_user(to, from, n) :		\
   __generic_copy_to_user(to, from, n))
  
  #define __copy_from_user(to, from, n) copy_from_user(to, from, n)
  #define __copy_to_user(to, from, n) copy_to_user(to, from, n)
  
  /*
   * Copy a null terminated string from userspace.
   */
  
  static inline long
  strncpy_from_user(char *dst, const char *src, long count)
  {
      long res;
      if (count == 0) return count;
      __asm__ __volatile__
  	("1: movesb (%2)+,%%d0\n"
  	 "12:moveb %%d0,(%1)+\n"
  	 "   jeq 2f\n"
  	 "   subql #1,%3\n"
  	 "   jne 1b\n"
  	 "2: subl %3,%0\n"
  	 "3:\n"
  	 ".section .fixup,\"ax\"\n"
  	 "   .even\n"
  	 "4: movel %4,%0\n"
  	 "   jra 3b\n"
  	 ".previous\n"
  	 ".section __ex_table,\"a\"\n"
  	 "   .align 4\n"
  	 "   .long 1b,4b\n"
  	 "   .long 12b,4b\n"
  	 ".previous"
  	 : "=d"(res), "=a"(dst), "=a"(src), "=d"(count)
  	 : "i"(-EFAULT), "0"(count), "1"(dst), "2"(src), "3"(count)
  	 : "d0", "memory");
      return res;
  }
  
  /*
   * Return the size of a string (including the ending 0)
   *
   * Return 0 on exception, a value greater than N if too long
   */
  static inline long strnlen_user(const char *src, long n)
  {
  	long res;
  
  	res = -(long)src;
  	__asm__ __volatile__
  		("1:\n"
  		 "   tstl %2\n"
  		 "   jeq 3f\n"
  		 "2: movesb (%1)+,%%d0\n"
  		 "22:\n"
  		 "   subql #1,%2\n"
  		 "   tstb %%d0\n"
  		 "   jne 1b\n"
  		 "   jra 4f\n"
  		 "3:\n"
  		 "   addql #1,%0\n"
  		 "4:\n"
  		 "   addl %1,%0\n"
  		 "5:\n"
  		 ".section .fixup,\"ax\"\n"
  		 "   .even\n"
  		 "6: moveq %3,%0\n"
  		 "   jra 5b\n"
  		 ".previous\n"
  		 ".section __ex_table,\"a\"\n"
  		 "   .align 4\n"
  		 "   .long 2b,6b\n"
  		 "   .long 22b,6b\n"
  		 ".previous"
  		 : "=d"(res), "=a"(src), "=d"(n)
  		 : "i"(0), "0"(res), "1"(src), "2"(n)
  		 : "d0");
  	return res;
  }
  
  #define strlen_user(str) strnlen_user(str, 32767)
  
  /*
   * Zero Userspace
   */
  
  static inline unsigned long
  clear_user(void *to, unsigned long n)
  {
      __asm__ __volatile__
  	("   tstl %1\n"
  	 "   jeq 3f\n"
  	 "1: movesl %3,(%0)+\n"
  	 "2: subql #1,%1\n"
  	 "   jne 1b\n"
  	 "3: movel %2,%1\n"
  	 "   bclr #1,%1\n"
  	 "   jeq 4f\n"
  	 "24:movesw %3,(%0)+\n"
  	 "4: bclr #0,%1\n"
  	 "   jeq 5f\n"
  	 "25:movesb %3,(%0)+\n"
  	 "5:\n"
  	 ".section .fixup,\"ax\"\n"
  	 "   .even\n"
  	 "61:addql #1,%1\n"
  	 "6: lsll #2,%1\n"
  	 "   addl %2,%1\n"
  	 "   jra 5b\n"
  	 "7: addql #2,%1\n"
  	 "   jra 5b\n"
  	 "8: addql #1,%1\n"
  	 "   jra 5b\n"
  	 ".previous\n"
  	 ".section __ex_table,\"a\"\n"
  	 "   .align 4\n"
  	 "   .long 1b,61b\n"
  	 "   .long 2b,6b\n"
  	 "   .long 3b,61b\n"
  	 "   .long 24b,7b\n"
  	 "   .long 4b,7b\n"
  	 "   .long 25b,8b\n"
  	 "   .long 5b,8b\n"
  	 ".previous"
  	 : "=a"(to), "=d"(n)
  	 : "r"(n & 3), "r"(0), "0"(to), "1"(n/4));
      return n;
  }
  
  #endif /* _M68K_UACCESS_H */
  