Commit 6510d419 authored by Harvey Harrison's avatar Harvey Harrison Committed by Linus Torvalds
Browse files

kernel: Move arches to use common unaligned access 



Unaligned access is ok for the following arches:
cris, m68k, mn10300, powerpc, s390, x86

Arches that use the memmove implementation for native endian, and
the byteshifting for the opposite endianness.
h8300, m32r, xtensa

Packed struct for native endian, byteshifting for other endian:
alpha, blackfin, ia64, parisc, sparc, sparc64, mips, sh

m86knommu is generic_be for Coldfire, otherwise unaligned access is ok.

frv, arm chooses endianness based on compiler settings, uses the byteshifting
versions.  Remove the unaligned trap handler from frv as it is now unused.

v850 is le, uses the byteshifting versions for both be and le.

Remove the now unused asm-generic implementation.

Signed-off-by: default avatarHarvey Harrison <harvey.harrison@gmail.com>
Acked-by: default avatarDavid S. Miller <davem@davemloft.net>
Cc: <linux-arch@vger.kernel.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 064106a9

arch/frv/kernel/traps.c

+2 −5
Original line number Diff line number Diff line
@@ -362,11 +362,8 @@ asmlinkage void memory_access_exception(unsigned long esr0, 
#ifdef CONFIG_MMU

	unsigned long fixup;



	if ((esr0 & ESRx_EC) == ESRx_EC_DATA_ACCESS)

		if (handle_misalignment(esr0, ear0, epcr0) == 0)

			return;



	if ((fixup = search_exception_table(__frame->pc)) != 0) {

	fixup = search_exception_table(__frame->pc);

	if (fixup) {

		__frame->pc = fixup;

		return;

	}

arch/frv/mm/unaligned.c

deleted100644 → 0
+0 −217
Original line number Diff line number Diff line 
/* unaligned.c: unalignment fixup handler for CPUs on which it is supported (FR451 only)

 *

 * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.

 * Written by David Howells (dhowells@redhat.com)

 *

 * 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; either version

 * 2 of the License, or (at your option) any later version.

 */



#include <linux/sched.h>

#include <linux/signal.h>

#include <linux/kernel.h>

#include <linux/mm.h>

#include <linux/types.h>

#include <linux/user.h>

#include <linux/string.h>

#include <linux/linkage.h>

#include <linux/init.h>



#include <asm/setup.h>

#include <asm/system.h>

#include <asm/uaccess.h>



#if 0

#define kdebug(fmt, ...) printk("FDPIC "fmt"\n" ,##__VA_ARGS__ )

#else

#define kdebug(fmt, ...) do {} while(0)

#endif



#define _MA_SIGNED	0x01

#define _MA_HALF	0x02

#define _MA_WORD	0x04

#define _MA_DWORD	0x08

#define _MA_SZ_MASK	0x0e

#define _MA_LOAD	0x10

#define _MA_STORE	0x20

#define _MA_UPDATE	0x40

#define _MA_IMM		0x80



#define _MA_LDxU	_MA_LOAD | _MA_UPDATE

#define _MA_LDxI	_MA_LOAD | _MA_IMM

#define _MA_STxU	_MA_STORE | _MA_UPDATE

#define _MA_STxI	_MA_STORE | _MA_IMM



static const uint8_t tbl_LDGRk_reg[0x40] = {

	[0x02] = _MA_LOAD | _MA_HALF | _MA_SIGNED,	/* LDSH  @(GRi,GRj),GRk */

	[0x03] = _MA_LOAD | _MA_HALF,			/* LDUH  @(GRi,GRj),GRk */

	[0x04] = _MA_LOAD | _MA_WORD,			/* LD	 @(GRi,GRj),GRk */

	[0x05] = _MA_LOAD | _MA_DWORD,			/* LDD	 @(GRi,GRj),GRk */

	[0x12] = _MA_LDxU | _MA_HALF | _MA_SIGNED,	/* LDSHU @(GRi,GRj),GRk */

	[0x13] = _MA_LDxU | _MA_HALF,			/* LDUHU @(GRi,GRj),GRk */

	[0x14] = _MA_LDxU | _MA_WORD,			/* LDU	 @(GRi,GRj),GRk */

	[0x15] = _MA_LDxU | _MA_DWORD,			/* LDDU	 @(GRi,GRj),GRk */

};



static const uint8_t tbl_STGRk_reg[0x40] = {

	[0x01] = _MA_STORE | _MA_HALF,			/* STH   @(GRi,GRj),GRk */

	[0x02] = _MA_STORE | _MA_WORD,			/* ST	 @(GRi,GRj),GRk */

	[0x03] = _MA_STORE | _MA_DWORD,			/* STD	 @(GRi,GRj),GRk */

	[0x11] = _MA_STxU  | _MA_HALF,			/* STHU  @(GRi,GRj),GRk */

	[0x12] = _MA_STxU  | _MA_WORD,			/* STU	 @(GRi,GRj),GRk */

	[0x13] = _MA_STxU  | _MA_DWORD,			/* STDU	 @(GRi,GRj),GRk */

};



static const uint8_t tbl_LDSTGRk_imm[0x80] = {

	[0x31] = _MA_LDxI | _MA_HALF | _MA_SIGNED,	/* LDSHI @(GRi,d12),GRk */

	[0x32] = _MA_LDxI | _MA_WORD,			/* LDI   @(GRi,d12),GRk */

	[0x33] = _MA_LDxI | _MA_DWORD,			/* LDDI  @(GRi,d12),GRk */

	[0x36] = _MA_LDxI | _MA_HALF,			/* LDUHI @(GRi,d12),GRk */

	[0x51] = _MA_STxI | _MA_HALF,			/* STHI  @(GRi,d12),GRk */

	[0x52] = _MA_STxI | _MA_WORD,			/* STI   @(GRi,d12),GRk */

	[0x53] = _MA_STxI | _MA_DWORD,			/* STDI  @(GRi,d12),GRk */

};





/*****************************************************************************/

/*

 * see if we can handle the exception by fixing up a misaligned memory access

 */

int handle_misalignment(unsigned long esr0, unsigned long ear0, unsigned long epcr0)

{

	unsigned long insn, addr, *greg;

	int GRi, GRj, GRk, D12, op;



	union {

		uint64_t _64;

		uint32_t _32[2];

		uint16_t _16;

		uint8_t _8[8];

	} x;



	if (!(esr0 & ESR0_EAV) || !(epcr0 & EPCR0_V) || !(ear0 & 7))

		return -EAGAIN;



	epcr0 &= EPCR0_PC;



	if (__frame->pc != epcr0) {

		kdebug("MISALIGN: Execution not halted on excepting instruction\n");

		BUG();

	}



	if (__get_user(insn, (unsigned long *) epcr0) < 0)

		return -EFAULT;



	/* determine the instruction type first */

	switch ((insn >> 18) & 0x7f) {

	case 0x2:

		/* LDx @(GRi,GRj),GRk */

		op = tbl_LDGRk_reg[(insn >> 6) & 0x3f];

		break;



	case 0x3:

		/* STx GRk,@(GRi,GRj) */

		op = tbl_STGRk_reg[(insn >> 6) & 0x3f];

		break;



	default:

		op = tbl_LDSTGRk_imm[(insn >> 18) & 0x7f];

		break;

	}



	if (!op)

		return -EAGAIN;



	kdebug("MISALIGN: pc=%08lx insn=%08lx ad=%08lx op=%02x\n", epcr0, insn, ear0, op);



	memset(&x, 0xba, 8);



	/* validate the instruction parameters */

	greg = (unsigned long *) &__frame->tbr;



	GRi = (insn >> 12) & 0x3f;

	GRk = (insn >> 25) & 0x3f;



	if (GRi > 31 || GRk > 31)

		return -ENOENT;



	if (op & _MA_DWORD && GRk & 1)

		return -EINVAL;



	if (op & _MA_IMM) {

		D12 = insn & 0xfff;

		asm ("slli %0,#20,%0 ! srai %0,#20,%0" : "=r"(D12) : "0"(D12)); /* sign extend */

		addr = (GRi ? greg[GRi] : 0) + D12;

	}

	else {

		GRj = (insn >>  0) & 0x3f;

		if (GRj > 31)

			return -ENOENT;

		addr = (GRi ? greg[GRi] : 0) + (GRj ? greg[GRj] : 0);

	}



	if (addr != ear0) {

		kdebug("MISALIGN: Calculated addr (%08lx) does not match EAR0 (%08lx)\n",

		       addr, ear0);

		return -EFAULT;

	}



	/* check the address is okay */

	if (user_mode(__frame) && ___range_ok(ear0, 8) < 0)

		return -EFAULT;



	/* perform the memory op */

	if (op & _MA_STORE) {

		/* perform a store */

		x._32[0] = 0;

		if (GRk != 0) {

			if (op & _MA_HALF) {

				x._16 = greg[GRk];

			}

			else {

				x._32[0] = greg[GRk];

			}

		}

		if (op & _MA_DWORD)

			x._32[1] = greg[GRk + 1];



		kdebug("MISALIGN: Store GR%d { %08x:%08x } -> %08lx (%dB)\n",

		       GRk, x._32[1], x._32[0], addr, op & _MA_SZ_MASK);



		if (__memcpy_user((void *) addr, &x, op & _MA_SZ_MASK) != 0)

			return -EFAULT;

	}

	else {

		/* perform a load */

		if (__memcpy_user(&x, (void *) addr, op & _MA_SZ_MASK) != 0)

			return -EFAULT;



		if (op & _MA_HALF) {

			if (op & _MA_SIGNED)

				asm ("slli %0,#16,%0 ! srai %0,#16,%0"

				     : "=r"(x._32[0]) : "0"(x._16));

			else

				asm ("sethi #0,%0"

				     : "=r"(x._32[0]) : "0"(x._16));

		}



		kdebug("MISALIGN: Load %08lx (%dB) -> GR%d, { %08x:%08x }\n",

		       addr, op & _MA_SZ_MASK, GRk, x._32[1], x._32[0]);



		if (GRk != 0)

			greg[GRk] = x._32[0];

		if (op & _MA_DWORD)

			greg[GRk + 1] = x._32[1];

	}



	/* update the base pointer if required */

	if (op & _MA_UPDATE)

		greg[GRi] = addr;



	/* well... we've done that insn */

	__frame->pc = __frame->pc + 4;



	return 0;

} /* end handle_misalignment() */

include/asm-alpha/unaligned.h

+9 −4
Original line number Diff line number Diff line 
#ifndef __ALPHA_UNALIGNED_H

#define __ALPHA_UNALIGNED_H

#ifndef _ASM_ALPHA_UNALIGNED_H

#define _ASM_ALPHA_UNALIGNED_H



#include <asm-generic/unaligned.h>

#include <linux/unaligned/le_struct.h>

#include <linux/unaligned/be_byteshift.h>

#include <linux/unaligned/generic.h>



#endif
 
#define get_unaligned __get_unaligned_le

#define put_unaligned __put_unaligned_le



#endif /* _ASM_ALPHA_UNALIGNED_H */

include/asm-arm/unaligned.h

+6 −168
Original line number Diff line number Diff line 
#ifndef __ASM_ARM_UNALIGNED_H

#define __ASM_ARM_UNALIGNED_H

#ifndef _ASM_ARM_UNALIGNED_H

#define _ASM_ARM_UNALIGNED_H



#include <asm/types.h>



extern int __bug_unaligned_x(const void *ptr);



/*

 * What is the most efficient way of loading/storing an unaligned value?

 *

 * That is the subject of this file.  Efficiency here is defined as

 * minimum code size with minimum register usage for the common cases.

 * It is currently not believed that long longs are common, so we

 * trade efficiency for the chars, shorts and longs against the long

 * longs.

 *

 * Current stats with gcc 2.7.2.2 for these functions:

 *

 *	ptrsize	get:	code	regs	put:	code	regs

 *	1		1	1		1	2

 *	2		3	2		3	2

 *	4		7	3		7	3

 *	8		20	6		16	6

 *

 * gcc 2.95.1 seems to code differently:

 *

 *	ptrsize	get:	code	regs	put:	code	regs

 *	1		1	1		1	2

 *	2		3	2		3	2

 *	4		7	4		7	4

 *	8		19	8		15	6

 *

 * which may or may not be more efficient (depending upon whether

 * you can afford the extra registers).  Hopefully the gcc 2.95

 * is inteligent enough to decide if it is better to use the

 * extra register, but evidence so far seems to suggest otherwise.

 *

 * Unfortunately, gcc is not able to optimise the high word

 * out of long long >> 32, or the low word from long long << 32

 */



#define __get_unaligned_2_le(__p)					\

	(unsigned int)(__p[0] | __p[1] << 8)



#define __get_unaligned_2_be(__p)					\

	(unsigned int)(__p[0] << 8 | __p[1])



#define __get_unaligned_4_le(__p)					\

	(unsigned int)(__p[0] | __p[1] << 8 | __p[2] << 16 | __p[3] << 24)



#define __get_unaligned_4_be(__p)					\

	(unsigned int)(__p[0] << 24 | __p[1] << 16 | __p[2] << 8 | __p[3])



#define __get_unaligned_8_le(__p)					\

	((unsigned long long)__get_unaligned_4_le((__p+4)) << 32 |	\

		__get_unaligned_4_le(__p))



#define __get_unaligned_8_be(__p)					\

	((unsigned long long)__get_unaligned_4_be(__p) << 32 |		\

		__get_unaligned_4_be((__p+4)))



#define __get_unaligned_le(ptr)						\

	((__force typeof(*(ptr)))({					\

		const __u8 *__p = (const __u8 *)(ptr);			\

		__builtin_choose_expr(sizeof(*(ptr)) == 1, *__p,	\

		  __builtin_choose_expr(sizeof(*(ptr)) == 2, __get_unaligned_2_le(__p),	\

		  __builtin_choose_expr(sizeof(*(ptr)) == 4, __get_unaligned_4_le(__p),	\

		  __builtin_choose_expr(sizeof(*(ptr)) == 8, __get_unaligned_8_le(__p),	\

		    (void)__bug_unaligned_x(__p)))));			\

	}))



#define __get_unaligned_be(ptr)						\

	((__force typeof(*(ptr)))({					\

		const __u8 *__p = (const __u8 *)(ptr);			\

		__builtin_choose_expr(sizeof(*(ptr)) == 1, *__p,	\

		  __builtin_choose_expr(sizeof(*(ptr)) == 2, __get_unaligned_2_be(__p),	\

		  __builtin_choose_expr(sizeof(*(ptr)) == 4, __get_unaligned_4_be(__p),	\

		  __builtin_choose_expr(sizeof(*(ptr)) == 8, __get_unaligned_8_be(__p),	\

		    (void)__bug_unaligned_x(__p)))));			\

	}))





static inline void __put_unaligned_2_le(__u32 __v, register __u8 *__p)

{

	*__p++ = __v;

	*__p++ = __v >> 8;

}



static inline void __put_unaligned_2_be(__u32 __v, register __u8 *__p)

{

	*__p++ = __v >> 8;

	*__p++ = __v;

}



static inline void __put_unaligned_4_le(__u32 __v, register __u8 *__p)

{

	__put_unaligned_2_le(__v >> 16, __p + 2);

	__put_unaligned_2_le(__v, __p);

}



static inline void __put_unaligned_4_be(__u32 __v, register __u8 *__p)

{

	__put_unaligned_2_be(__v >> 16, __p);

	__put_unaligned_2_be(__v, __p + 2);

}



static inline void __put_unaligned_8_le(const unsigned long long __v, register __u8 *__p)

{

	/*

	 * tradeoff: 8 bytes of stack for all unaligned puts (2

	 * instructions), or an extra register in the long long

	 * case - go for the extra register.

	 */

	__put_unaligned_4_le(__v >> 32, __p+4);

	__put_unaligned_4_le(__v, __p);

}



static inline void __put_unaligned_8_be(const unsigned long long __v, register __u8 *__p)

{

	/*

	 * tradeoff: 8 bytes of stack for all unaligned puts (2

	 * instructions), or an extra register in the long long

	 * case - go for the extra register.

	 */

	__put_unaligned_4_be(__v >> 32, __p);

	__put_unaligned_4_be(__v, __p+4);

}



/*

 * Try to store an unaligned value as efficiently as possible.

 */

#define __put_unaligned_le(val,ptr)					\

	({							\

		(void)sizeof(*(ptr) = (val));			\

		switch (sizeof(*(ptr))) {			\

		case 1:						\

			*(ptr) = (val);				\

			break;					\

		case 2: __put_unaligned_2_le((__force u16)(val),(__u8 *)(ptr));	\

			break;					\

		case 4:	__put_unaligned_4_le((__force u32)(val),(__u8 *)(ptr));	\

			break;					\

		case 8:	__put_unaligned_8_le((__force u64)(val),(__u8 *)(ptr)); \

			break;					\

		default: __bug_unaligned_x(ptr);		\

			break;					\

		}						\

		(void) 0;					\

	})



#define __put_unaligned_be(val,ptr)					\

	({							\

		(void)sizeof(*(ptr) = (val));			\

		switch (sizeof(*(ptr))) {			\

		case 1:						\

			*(ptr) = (val);				\

			break;					\

		case 2: __put_unaligned_2_be((__force u16)(val),(__u8 *)(ptr));	\

			break;					\

		case 4:	__put_unaligned_4_be((__force u32)(val),(__u8 *)(ptr));	\

			break;					\

		case 8:	__put_unaligned_8_be((__force u64)(val),(__u8 *)(ptr)); \

			break;					\

		default: __bug_unaligned_x(ptr);		\

			break;					\

		}						\

		(void) 0;					\

	})

#include <linux/unaligned/le_byteshift.h>

#include <linux/unaligned/be_byteshift.h>

#include <linux/unaligned/generic.h>



/*

 * Select endianness
@@ -178,4 +16,4 @@ static inline void __put_unaligned_8_be(const unsigned long long __v, register _ 
#define put_unaligned	__put_unaligned_be

#endif



#endif
 
#endif /* _ASM_ARM_UNALIGNED_H */

include/asm-avr32/unaligned.h

+9 −4
Original line number Diff line number Diff line 
#ifndef __ASM_AVR32_UNALIGNED_H

#define __ASM_AVR32_UNALIGNED_H

#ifndef _ASM_AVR32_UNALIGNED_H

#define _ASM_AVR32_UNALIGNED_H



/*

 * AVR32 can handle some unaligned accesses, depending on the
@@ -11,6 +11,11 @@ 
 * optimize word loads in general.

 */



#include <asm-generic/unaligned.h>

#include <linux/unaligned/be_struct.h>

#include <linux/unaligned/le_byteshift.h>

#include <linux/unaligned/generic.h>



#endif /* __ASM_AVR32_UNALIGNED_H */
 
#define get_unaligned	__get_unaligned_be

#define put_unaligned	__put_unaligned_be



#endif /* _ASM_AVR32_UNALIGNED_H */

CRA Git | Maintained and supported by SUSTech CRA and CCSE