sparc32: Kill off software 32-bit multiply/divide routines. (1b35a57b) · Commits · 戴 / test

arch/sparc/kernel/entry.S

+16 −11

Original line number	Diff line number	Diff line
		@@ -1161,11 +1161,13 @@ fpload:
		.globl __ndelay
		__ndelay:
		save %sp, -STACKFRAME_SZ, %sp
		mov %i0, %o0
		call .umul ! round multiplier up so large ns ok
		mov %i0, %o0 ! round multiplier up so large ns ok
		mov 0x1ae, %o1 ! 2**32 / (1 000 000 000 / HZ)
		call .umul
		umul %o0, %o1, %o0
		rd %y, %o1
		mov %i1, %o1 ! udelay_val
		umul %o0, %o1, %o0
		rd %y, %o1
		ba delay_continue
		mov %o1, %o0 ! >>32 later for better resolution

		@@ -1174,18 +1176,21 @@ __udelay:
		save %sp, -STACKFRAME_SZ, %sp
		mov %i0, %o0
		sethi %hi(0x10c7), %o1 ! round multiplier up so large us ok
		call .umul
		or %o1, %lo(0x10c7), %o1 ! 2**32 / 1 000 000
		call .umul
		umul %o0, %o1, %o0
		rd %y, %o1
		mov %i1, %o1 ! udelay_val
		umul %o0, %o1, %o0
		rd %y, %o1
		sethi %hi(0x028f4b62), %l0 ! Add in rounding constant * 2**32,
		or %g0, %lo(0x028f4b62), %l0
		addcc %o0, %l0, %o0 ! 2*32 0.009 999
		bcs,a 3f
		add %o1, 0x01, %o1
		3:
		call .umul
		mov HZ, %o0 ! >>32 earlier for wider range
		umul %o0, %o1, %o0
		rd %y, %o1

		delay_continue:
		cmp %o0, 0x0

arch/sparc/kernel/head_32.S

+0 −45

Original line number	Diff line number	Diff line
		@@ -746,51 +746,6 @@ sun4d_init:
		/* Fall through to sun4m_init */

		sun4m_init:

		#define PATCH_IT(dst, src) \
		set (dst), %g5; \
		set (src), %g4; \
		ld [%g4], %g3; \
		st %g3, [%g5]; \
		ld [%g4+0x4], %g3; \
		st %g3, [%g5+0x4];

		/* Signed multiply. */
		PATCH_IT(.mul, .mul_patch)
		PATCH_IT(.mul+0x08, .mul_patch+0x08)

		/* Signed remainder. */
		PATCH_IT(.rem, .rem_patch)
		PATCH_IT(.rem+0x08, .rem_patch+0x08)
		PATCH_IT(.rem+0x10, .rem_patch+0x10)
		PATCH_IT(.rem+0x18, .rem_patch+0x18)
		PATCH_IT(.rem+0x20, .rem_patch+0x20)
		PATCH_IT(.rem+0x28, .rem_patch+0x28)

		/* Signed division. */
		PATCH_IT(.div, .div_patch)
		PATCH_IT(.div+0x08, .div_patch+0x08)
		PATCH_IT(.div+0x10, .div_patch+0x10)
		PATCH_IT(.div+0x18, .div_patch+0x18)
		PATCH_IT(.div+0x20, .div_patch+0x20)

		/* Unsigned multiply. */
		PATCH_IT(.umul, .umul_patch)
		PATCH_IT(.umul+0x08, .umul_patch+0x08)

		/* Unsigned remainder. */
		PATCH_IT(.urem, .urem_patch)
		PATCH_IT(.urem+0x08, .urem_patch+0x08)
		PATCH_IT(.urem+0x10, .urem_patch+0x10)
		PATCH_IT(.urem+0x18, .urem_patch+0x18)

		/* Unsigned division. */
		PATCH_IT(.udiv, .udiv_patch)
		PATCH_IT(.udiv+0x08, .udiv_patch+0x08)
		PATCH_IT(.udiv+0x10, .udiv_patch+0x10)

		#undef PATCH_IT

		/* Ok, the PROM could have done funny things and apple cider could still
		* be sitting in the fault status/address registers. Read them all to
		* clear them so we don't get magic faults later on.

arch/sparc/kernel/kernel.h

+0 −3

Original line number	Diff line number	Diff line
		@@ -32,9 +32,6 @@ extern void cpu_probe(void);
		/* traps_32.c */
		extern void handle_hw_divzero(struct pt_regs *regs, unsigned long pc,
		unsigned long npc, unsigned long psr);
		/* muldiv.c */
		extern int do_user_muldiv (struct pt_regs *, unsigned long);

		/* irq_32.c */
		extern struct irqaction static_irqaction[];
		extern int static_irq_count;

arch/sparc/kernel/module.c

+1 −20

Original line number	Diff line number	Diff line
		@@ -32,26 +32,11 @@ static void *module_map(unsigned long size)
		GFP_KERNEL, PAGE_KERNEL, -1,
		__builtin_return_address(0));
		}

		static char dot2underscore(char name)
		{
		return name;
		}
		#else
		static void *module_map(unsigned long size)
		{
		return vmalloc(size);
		}

		/* Replace references to .func with _Func */
		static char dot2underscore(char name)
		{
		if (name[0] == '.') {
		name[0] = '_';
		name[1] = toupper(name[1]);
		}
		return name;
		}
		#endif /* CONFIG_SPARC64 */

		void *module_alloc(unsigned long size)
		@@ -93,12 +78,8 @@ int module_frob_arch_sections(Elf_Ehdr *hdr,

		for (i = 1; i < sechdrs[symidx].sh_size / sizeof(Elf_Sym); i++) {
		if (sym[i].st_shndx == SHN_UNDEF) {
		if (ELF_ST_TYPE(sym[i].st_info) == STT_REGISTER) {
		if (ELF_ST_TYPE(sym[i].st_info) == STT_REGISTER)
		sym[i].st_shndx = SHN_ABS;
		} else {
		char *name = strtab + sym[i].st_name;
		dot2underscore(name);
		}
		}
		}
		return 0;

arch/sparc/kernel/muldiv.c

deleted100644 → 0

+0 −238

Original line number	Diff line number	Diff line
		/*
		* muldiv.c: Hardware multiply/division illegal instruction trap
		* for sun4c/sun4 (which do not have those instructions)
		*
		* Copyright (C) 1996 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
		* Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
		*
		* 2004-12-25 Krzysztof Helt (krzysztof.h1@wp.pl)
		* - fixed registers constrains in inline assembly declarations
		*/

		#include <linux/kernel.h>
		#include <linux/sched.h>
		#include <linux/mm.h>
		#include <asm/ptrace.h>
		#include <asm/processor.h>
		#include <asm/uaccess.h>

		#include "kernel.h"

		/* #define DEBUG_MULDIV */

		static inline int has_imm13(int insn)
		{
		return (insn & 0x2000);
		}

		static inline int is_foocc(int insn)
		{
		return (insn & 0x800000);
		}

		static inline int sign_extend_imm13(int imm)
		{
		return imm << 19 >> 19;
		}

		static inline void advance(struct pt_regs *regs)
		{
		regs->pc = regs->npc;
		regs->npc += 4;
		}

		static inline void maybe_flush_windows(unsigned int rs1, unsigned int rs2,
		unsigned int rd)
		{
		if(rs2 >= 16 \|\| rs1 >= 16 \|\| rd >= 16) {
		/* Wheee... */
		__asm__ __volatile__("save %sp, -0x40, %sp\n\t"
		"save %sp, -0x40, %sp\n\t"
		"save %sp, -0x40, %sp\n\t"
		"save %sp, -0x40, %sp\n\t"
		"save %sp, -0x40, %sp\n\t"
		"save %sp, -0x40, %sp\n\t"
		"save %sp, -0x40, %sp\n\t"
		"restore; restore; restore; restore;\n\t"
		"restore; restore; restore;\n\t");
		}
		}

		#define fetch_reg(reg, regs) ({ \
		struct reg_window32 __user *win; \
		register unsigned long ret; \
		\
		if (!(reg)) ret = 0; \
		else if ((reg) < 16) { \
		ret = regs->u_regs[(reg)]; \
		} else { \
		/* Ho hum, the slightly complicated case. */ \
		win = (struct reg_window32 __user *)regs->u_regs[UREG_FP];\
		if (get_user (ret, &win->locals[(reg) - 16])) return -1;\
		} \
		ret; \
		})

		static inline int
		store_reg(unsigned int result, unsigned int reg, struct pt_regs *regs)
		{
		struct reg_window32 __user *win;

		if (!reg)
		return 0;
		if (reg < 16) {
		regs->u_regs[reg] = result;
		return 0;
		} else {
		/* need to use put_user() in this case: */
		win = (struct reg_window32 __user *) regs->u_regs[UREG_FP];
		return (put_user(result, &win->locals[reg - 16]));
		}
		}

		/* Should return 0 if mul/div emulation succeeded and SIGILL should
		* not be issued.
		*/
		int do_user_muldiv(struct pt_regs *regs, unsigned long pc)
		{
		unsigned int insn;
		int inst;
		unsigned int rs1, rs2, rdv;

		if (!pc)
		return -1; /* This happens to often, I think */
		if (get_user (insn, (unsigned int __user *)pc))
		return -1;
		if ((insn & 0xc1400000) != 0x80400000)
		return -1;
		inst = ((insn >> 19) & 0xf);
		if ((inst & 0xe) != 10 && (inst & 0xe) != 14)
		return -1;

		/* Now we know we have to do something with umul, smul, udiv or sdiv */
		rs1 = (insn >> 14) & 0x1f;
		rs2 = insn & 0x1f;
		rdv = (insn >> 25) & 0x1f;
		if (has_imm13(insn)) {
		maybe_flush_windows(rs1, 0, rdv);
		rs2 = sign_extend_imm13(insn);
		} else {
		maybe_flush_windows(rs1, rs2, rdv);
		rs2 = fetch_reg(rs2, regs);
		}
		rs1 = fetch_reg(rs1, regs);
		switch (inst) {
		case 10: /* umul */
		#ifdef DEBUG_MULDIV
		printk ("unsigned muldiv: 0x%x * 0x%x = ", rs1, rs2);
		#endif
		__asm__ __volatile__ ("\n\t"
		"mov %0, %%o0\n\t"
		"call .umul\n\t"
		" mov %1, %%o1\n\t"
		"mov %%o0, %0\n\t"
		"mov %%o1, %1\n\t"
		: "=r" (rs1), "=r" (rs2)
		: "0" (rs1), "1" (rs2)
		: "o0", "o1", "o2", "o3", "o4", "o5", "o7", "cc");
		#ifdef DEBUG_MULDIV
		printk ("0x%x%08x\n", rs2, rs1);
		#endif
		if (store_reg(rs1, rdv, regs))
		return -1;
		regs->y = rs2;
		break;
		case 11: /* smul */
		#ifdef DEBUG_MULDIV
		printk ("signed muldiv: 0x%x * 0x%x = ", rs1, rs2);
		#endif
		__asm__ __volatile__ ("\n\t"
		"mov %0, %%o0\n\t"
		"call .mul\n\t"
		" mov %1, %%o1\n\t"
		"mov %%o0, %0\n\t"
		"mov %%o1, %1\n\t"
		: "=r" (rs1), "=r" (rs2)
		: "0" (rs1), "1" (rs2)
		: "o0", "o1", "o2", "o3", "o4", "o5", "o7", "cc");
		#ifdef DEBUG_MULDIV
		printk ("0x%x%08x\n", rs2, rs1);
		#endif
		if (store_reg(rs1, rdv, regs))
		return -1;
		regs->y = rs2;
		break;
		case 14: /* udiv */
		#ifdef DEBUG_MULDIV
		printk ("unsigned muldiv: 0x%x%08x / 0x%x = ", regs->y, rs1, rs2);
		#endif
		if (!rs2) {
		#ifdef DEBUG_MULDIV
		printk ("DIVISION BY ZERO\n");
		#endif
		handle_hw_divzero (regs, pc, regs->npc, regs->psr);
		return 0;
		}
		__asm__ __volatile__ ("\n\t"
		"mov %2, %%o0\n\t"
		"mov %0, %%o1\n\t"
		"mov %%g0, %%o2\n\t"
		"call __udivdi3\n\t"
		" mov %1, %%o3\n\t"
		"mov %%o1, %0\n\t"
		"mov %%o0, %1\n\t"
		: "=r" (rs1), "=r" (rs2)
		: "r" (regs->y), "0" (rs1), "1" (rs2)
		: "o0", "o1", "o2", "o3", "o4", "o5", "o7",
		"g1", "g2", "g3", "cc");
		#ifdef DEBUG_MULDIV
		printk ("0x%x\n", rs1);
		#endif
		if (store_reg(rs1, rdv, regs))
		return -1;
		break;
		case 15: /* sdiv */
		#ifdef DEBUG_MULDIV
		printk ("signed muldiv: 0x%x%08x / 0x%x = ", regs->y, rs1, rs2);
		#endif
		if (!rs2) {
		#ifdef DEBUG_MULDIV
		printk ("DIVISION BY ZERO\n");
		#endif
		handle_hw_divzero (regs, pc, regs->npc, regs->psr);
		return 0;
		}
		__asm__ __volatile__ ("\n\t"
		"mov %2, %%o0\n\t"
		"mov %0, %%o1\n\t"
		"mov %%g0, %%o2\n\t"
		"call __divdi3\n\t"
		" mov %1, %%o3\n\t"
		"mov %%o1, %0\n\t"
		"mov %%o0, %1\n\t"
		: "=r" (rs1), "=r" (rs2)
		: "r" (regs->y), "0" (rs1), "1" (rs2)
		: "o0", "o1", "o2", "o3", "o4", "o5", "o7",
		"g1", "g2", "g3", "cc");
		#ifdef DEBUG_MULDIV
		printk ("0x%x\n", rs1);
		#endif
		if (store_reg(rs1, rdv, regs))
		return -1;
		break;
		}
		if (is_foocc (insn)) {
		regs->psr &= ~PSR_ICC;
		if ((inst & 0xe) == 14) {
		/* ?div */
		if (rs2) regs->psr \|= PSR_V;
		}
		if (!rs1) regs->psr \|= PSR_Z;
		if (((int)rs1) < 0) regs->psr \|= PSR_N;
		#ifdef DEBUG_MULDIV
		printk ("psr muldiv: %08x\n", regs->psr);
		#endif
		}
		advance(regs);
		return 0;
		}

Admin message