From 3d0d14f983b55a570b976976284df4c434af3223 Mon Sep 17 00:00:00 2001
From: Ingo Molnar <mingo@elte.hu>
Date: Wed, 30 Jan 2008 13:30:11 +0100
Subject: x86: lindent arch/i386/math-emu

lindent these files:
                                       errors   lines of code   errors/KLOC
 arch/x86/math-emu/                      2236            9424         237.2
 arch/x86/math-emu/                       128            8706          14.7

no other changes. No code changed:

   text    data     bss     dec     hex filename
   5589802  612739 3833856 10036397         9924ad vmlinux.before
   5589802  612739 3833856 10036397         9924ad vmlinux.after

the intent of this patch is to ease the automated tracking of kernel
code quality - it's just much easier for us to maintain it if every file
in arch/x86 is supposed to be clean.

NOTE: it is a known problem of lindent that it causes some style damage
of its own, but it's a safe tool (well, except for the gcc array range
initializers extension), so we did the bulk of the changes via lindent,
and did the manual fixups in a followup patch.

the resulting math-emu code has been tested by Thomas Gleixner on a real
386 DX CPU as well, and it works fine.

Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
---
 arch/x86/math-emu/poly_2xm1.c | 199 ++++++++++++++++++++----------------------
 1 file changed, 94 insertions(+), 105 deletions(-)

(limited to 'arch/x86/math-emu/poly_2xm1.c')

diff --git a/arch/x86/math-emu/poly_2xm1.c b/arch/x86/math-emu/poly_2xm1.c
index 9766ad5e9743..d8f2be3c8383 100644
--- a/arch/x86/math-emu/poly_2xm1.c
+++ b/arch/x86/math-emu/poly_2xm1.c
@@ -17,21 +17,19 @@
 #include "control_w.h"
 #include "poly.h"
 
-
 #define	HIPOWER	11
-static const unsigned long long lterms[HIPOWER] =
-{
-  0x0000000000000000LL,  /* This term done separately as 12 bytes */
-  0xf5fdeffc162c7543LL,
-  0x1c6b08d704a0bfa6LL,
-  0x0276556df749cc21LL,
-  0x002bb0ffcf14f6b8LL,
-  0x0002861225ef751cLL,
-  0x00001ffcbfcd5422LL,
-  0x00000162c005d5f1LL,
-  0x0000000da96ccb1bLL,
-  0x0000000078d1b897LL,
-  0x000000000422b029LL
+static const unsigned long long lterms[HIPOWER] = {
+	0x0000000000000000LL,	/* This term done separately as 12 bytes */
+	0xf5fdeffc162c7543LL,
+	0x1c6b08d704a0bfa6LL,
+	0x0276556df749cc21LL,
+	0x002bb0ffcf14f6b8LL,
+	0x0002861225ef751cLL,
+	0x00001ffcbfcd5422LL,
+	0x00000162c005d5f1LL,
+	0x0000000da96ccb1bLL,
+	0x0000000078d1b897LL,
+	0x000000000422b029LL
 };
 
 static const Xsig hiterm = MK_XSIG(0xb17217f7, 0xd1cf79ab, 0xc8a39194);
@@ -45,112 +43,103 @@ static const Xsig shiftterm2 = MK_XSIG(0xb504f333, 0xf9de6484, 0x597d89b3);
 static const Xsig shiftterm3 = MK_XSIG(0xd744fcca, 0xd69d6af4, 0x39a68bb9);
 
 static const Xsig *shiftterm[] = { &shiftterm0, &shiftterm1,
-				     &shiftterm2, &shiftterm3 };
-
+	&shiftterm2, &shiftterm3
+};
 
 /*--- poly_2xm1() -----------------------------------------------------------+
  | Requires st(0) which is TAG_Valid and < 1.                                |
  +---------------------------------------------------------------------------*/
-int	poly_2xm1(u_char sign, FPU_REG *arg, FPU_REG *result)
+int poly_2xm1(u_char sign, FPU_REG * arg, FPU_REG * result)
 {
-  long int              exponent, shift;
-  unsigned long long    Xll;
-  Xsig                  accumulator, Denom, argSignif;
-  u_char                tag;
+	long int exponent, shift;
+	unsigned long long Xll;
+	Xsig accumulator, Denom, argSignif;
+	u_char tag;
 
-  exponent = exponent16(arg);
+	exponent = exponent16(arg);
 
 #ifdef PARANOID
-  if ( exponent >= 0 )    	/* Don't want a |number| >= 1.0 */
-    {
-      /* Number negative, too large, or not Valid. */
-      EXCEPTION(EX_INTERNAL|0x127);
-      return 1;
-    }
+	if (exponent >= 0) {	/* Don't want a |number| >= 1.0 */
+		/* Number negative, too large, or not Valid. */
+		EXCEPTION(EX_INTERNAL | 0x127);
+		return 1;
+	}
 #endif /* PARANOID */
 
-  argSignif.lsw = 0;
-  XSIG_LL(argSignif) = Xll = significand(arg);
-
-  if ( exponent == -1 )
-    {
-      shift = (argSignif.msw & 0x40000000) ? 3 : 2;
-      /* subtract 0.5 or 0.75 */
-      exponent -= 2;
-      XSIG_LL(argSignif) <<= 2;
-      Xll <<= 2;
-    }
-  else if ( exponent == -2 )
-    {
-      shift = 1;
-      /* subtract 0.25 */
-      exponent--;
-      XSIG_LL(argSignif) <<= 1;
-      Xll <<= 1;
-    }
-  else
-    shift = 0;
-
-  if ( exponent < -2 )
-    {
-      /* Shift the argument right by the required places. */
-      if ( FPU_shrx(&Xll, -2-exponent) >= 0x80000000U )
-	Xll++;	/* round up */
-    }
-
-  accumulator.lsw = accumulator.midw = accumulator.msw = 0;
-  polynomial_Xsig(&accumulator, &Xll, lterms, HIPOWER-1);
-  mul_Xsig_Xsig(&accumulator, &argSignif);
-  shr_Xsig(&accumulator, 3);
-
-  mul_Xsig_Xsig(&argSignif, &hiterm);   /* The leading term */
-  add_two_Xsig(&accumulator, &argSignif, &exponent);
-
-  if ( shift )
-    {
-      /* The argument is large, use the identity:
-	 f(x+a) = f(a) * (f(x) + 1) - 1;
-	 */
-      shr_Xsig(&accumulator, - exponent);
-      accumulator.msw |= 0x80000000;      /* add 1.0 */
-      mul_Xsig_Xsig(&accumulator, shiftterm[shift]);
-      accumulator.msw &= 0x3fffffff;      /* subtract 1.0 */
-      exponent = 1;
-    }
-
-  if ( sign != SIGN_POS )
-    {
-      /* The argument is negative, use the identity:
-	     f(-x) = -f(x) / (1 + f(x))
-	 */
-      Denom.lsw = accumulator.lsw;
-      XSIG_LL(Denom) = XSIG_LL(accumulator);
-      if ( exponent < 0 )
-	shr_Xsig(&Denom, - exponent);
-      else if ( exponent > 0 )
-	{
-	  /* exponent must be 1 here */
-	  XSIG_LL(Denom) <<= 1;
-	  if ( Denom.lsw & 0x80000000 )
-	    XSIG_LL(Denom) |= 1;
-	  (Denom.lsw) <<= 1;
+	argSignif.lsw = 0;
+	XSIG_LL(argSignif) = Xll = significand(arg);
+
+	if (exponent == -1) {
+		shift = (argSignif.msw & 0x40000000) ? 3 : 2;
+		/* subtract 0.5 or 0.75 */
+		exponent -= 2;
+		XSIG_LL(argSignif) <<= 2;
+		Xll <<= 2;
+	} else if (exponent == -2) {
+		shift = 1;
+		/* subtract 0.25 */
+		exponent--;
+		XSIG_LL(argSignif) <<= 1;
+		Xll <<= 1;
+	} else
+		shift = 0;
+
+	if (exponent < -2) {
+		/* Shift the argument right by the required places. */
+		if (FPU_shrx(&Xll, -2 - exponent) >= 0x80000000U)
+			Xll++;	/* round up */
+	}
+
+	accumulator.lsw = accumulator.midw = accumulator.msw = 0;
+	polynomial_Xsig(&accumulator, &Xll, lterms, HIPOWER - 1);
+	mul_Xsig_Xsig(&accumulator, &argSignif);
+	shr_Xsig(&accumulator, 3);
+
+	mul_Xsig_Xsig(&argSignif, &hiterm);	/* The leading term */
+	add_two_Xsig(&accumulator, &argSignif, &exponent);
+
+	if (shift) {
+		/* The argument is large, use the identity:
+		   f(x+a) = f(a) * (f(x) + 1) - 1;
+		 */
+		shr_Xsig(&accumulator, -exponent);
+		accumulator.msw |= 0x80000000;	/* add 1.0 */
+		mul_Xsig_Xsig(&accumulator, shiftterm[shift]);
+		accumulator.msw &= 0x3fffffff;	/* subtract 1.0 */
+		exponent = 1;
+	}
+
+	if (sign != SIGN_POS) {
+		/* The argument is negative, use the identity:
+		   f(-x) = -f(x) / (1 + f(x))
+		 */
+		Denom.lsw = accumulator.lsw;
+		XSIG_LL(Denom) = XSIG_LL(accumulator);
+		if (exponent < 0)
+			shr_Xsig(&Denom, -exponent);
+		else if (exponent > 0) {
+			/* exponent must be 1 here */
+			XSIG_LL(Denom) <<= 1;
+			if (Denom.lsw & 0x80000000)
+				XSIG_LL(Denom) |= 1;
+			(Denom.lsw) <<= 1;
+		}
+		Denom.msw |= 0x80000000;	/* add 1.0 */
+		div_Xsig(&accumulator, &Denom, &accumulator);
 	}
-      Denom.msw |= 0x80000000;      /* add 1.0 */
-      div_Xsig(&accumulator, &Denom, &accumulator);
-    }
 
-  /* Convert to 64 bit signed-compatible */
-  exponent += round_Xsig(&accumulator);
+	/* Convert to 64 bit signed-compatible */
+	exponent += round_Xsig(&accumulator);
 
-  result = &st(0);
-  significand(result) = XSIG_LL(accumulator);
-  setexponent16(result, exponent);
+	result = &st(0);
+	significand(result) = XSIG_LL(accumulator);
+	setexponent16(result, exponent);
 
-  tag = FPU_round(result, 1, 0, FULL_PRECISION, sign);
+	tag = FPU_round(result, 1, 0, FULL_PRECISION, sign);
 
-  setsign(result, sign);
-  FPU_settag0(tag);
+	setsign(result, sign);
+	FPU_settag0(tag);
 
-  return 0;
+	return 0;
 
 }
-- 
cgit v1.2.3


From e8d591dc710158bae6b53c8b7a0172351025c6e2 Mon Sep 17 00:00:00 2001
From: Ingo Molnar <mingo@elte.hu>
Date: Wed, 30 Jan 2008 13:30:12 +0100
Subject: x86: lindent arch/i386/math-emu, cleanup

manually clean up some of the damage that lindent caused.
(this is a separate commit so that in the unlikely case of
a typo we can bisect it down to the manual edits.)

Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
---
 arch/x86/math-emu/errors.c      |  6 ++--
 arch/x86/math-emu/fpu_emu.h     | 12 ++++----
 arch/x86/math-emu/fpu_entry.c   |  6 ++--
 arch/x86/math-emu/fpu_etc.c     |  8 +++---
 arch/x86/math-emu/fpu_proto.h   | 62 ++++++++++++++++++++---------------------
 arch/x86/math-emu/fpu_trig.c    | 38 ++++++++++++-------------
 arch/x86/math-emu/poly.h        | 10 +++----
 arch/x86/math-emu/poly_2xm1.c   |  2 +-
 arch/x86/math-emu/poly_atan.c   |  4 +--
 arch/x86/math-emu/poly_l2.c     |  4 +--
 arch/x86/math-emu/poly_sin.c    |  4 +--
 arch/x86/math-emu/poly_tan.c    |  2 +-
 arch/x86/math-emu/reg_convert.c |  2 +-
 arch/x86/math-emu/reg_ld_str.c  | 42 ++++++++++++++--------------
 14 files changed, 101 insertions(+), 101 deletions(-)

(limited to 'arch/x86/math-emu/poly_2xm1.c')

diff --git a/arch/x86/math-emu/errors.c b/arch/x86/math-emu/errors.c
index 7cb5bf3495b2..145b68a99516 100644
--- a/arch/x86/math-emu/errors.c
+++ b/arch/x86/math-emu/errors.c
@@ -374,7 +374,7 @@ asmlinkage void FPU_exception(int n)
 
 /* Real operation attempted on a NaN. */
 /* Returns < 0 if the exception is unmasked */
-int real_1op_NaN(FPU_REG * a)
+int real_1op_NaN(FPU_REG *a)
 {
 	int signalling, isNaN;
 
@@ -573,7 +573,7 @@ asmlinkage int denormal_operand(void)
 	}
 }
 
-asmlinkage int arith_overflow(FPU_REG * dest)
+asmlinkage int arith_overflow(FPU_REG *dest)
 {
 	int tag = TAG_Valid;
 
@@ -601,7 +601,7 @@ asmlinkage int arith_overflow(FPU_REG * dest)
 
 }
 
-asmlinkage int arith_underflow(FPU_REG * dest)
+asmlinkage int arith_underflow(FPU_REG *dest)
 {
 	int tag = TAG_Valid;
 
diff --git a/arch/x86/math-emu/fpu_emu.h b/arch/x86/math-emu/fpu_emu.h
index 656dd4c04b1b..4dae511c85ad 100644
--- a/arch/x86/math-emu/fpu_emu.h
+++ b/arch/x86/math-emu/fpu_emu.h
@@ -122,7 +122,7 @@ struct fpu__reg {
 
 typedef void (*FUNC) (void);
 typedef struct fpu__reg FPU_REG;
-typedef void (*FUNC_ST0) (FPU_REG * st0_ptr, u_char st0_tag);
+typedef void (*FUNC_ST0) (FPU_REG *st0_ptr, u_char st0_tag);
 typedef struct {
 	u_char address_size, operand_size, segment;
 } overrides;
@@ -166,7 +166,7 @@ extern u_char const data_sizes_16[32];
 #define signpositive(a) ( (signbyte(a) & 0x80) == 0 )
 #define signnegative(a) (signbyte(a) & 0x80)
 
-static inline void reg_copy(FPU_REG const *x, FPU_REG * y)
+static inline void reg_copy(FPU_REG const *x, FPU_REG *y)
 {
 	*(short *)&(y->exp) = *(const short *)&(x->exp);
 	*(long long *)&(y->sigl) = *(const long long *)&(x->sigl);
@@ -187,8 +187,8 @@ static inline void reg_copy(FPU_REG const *x, FPU_REG * y)
 /*----- Prototypes for functions written in assembler -----*/
 /* extern void reg_move(FPU_REG *a, FPU_REG *b); */
 
-asmlinkage int FPU_normalize(FPU_REG * x);
-asmlinkage int FPU_normalize_nuo(FPU_REG * x);
+asmlinkage int FPU_normalize(FPU_REG *x);
+asmlinkage int FPU_normalize_nuo(FPU_REG *x);
 asmlinkage int FPU_u_sub(FPU_REG const *arg1, FPU_REG const *arg2,
 			 FPU_REG * answ, unsigned int control_w, u_char sign,
 			 int expa, int expb);
@@ -200,12 +200,12 @@ asmlinkage int FPU_u_div(FPU_REG const *arg1, FPU_REG const *arg2,
 asmlinkage int FPU_u_add(FPU_REG const *arg1, FPU_REG const *arg2,
 			 FPU_REG * answ, unsigned int control_w, u_char sign,
 			 int expa, int expb);
-asmlinkage int wm_sqrt(FPU_REG * n, int dummy1, int dummy2,
+asmlinkage int wm_sqrt(FPU_REG *n, int dummy1, int dummy2,
 		       unsigned int control_w, u_char sign);
 asmlinkage unsigned FPU_shrx(void *l, unsigned x);
 asmlinkage unsigned FPU_shrxs(void *v, unsigned x);
 asmlinkage unsigned long FPU_div_small(unsigned long long *x, unsigned long y);
-asmlinkage int FPU_round(FPU_REG * arg, unsigned int extent, int dummy,
+asmlinkage int FPU_round(FPU_REG *arg, unsigned int extent, int dummy,
 			 unsigned int control_w, u_char sign);
 
 #ifndef MAKING_PROTO
diff --git a/arch/x86/math-emu/fpu_entry.c b/arch/x86/math-emu/fpu_entry.c
index cbb8717f09fd..377c60dfa2f0 100644
--- a/arch/x86/math-emu/fpu_entry.c
+++ b/arch/x86/math-emu/fpu_entry.c
@@ -126,7 +126,7 @@ static u_char const type_table[64] = {
 u_char emulating = 0;
 #endif /* RE_ENTRANT_CHECKING */
 
-static int valid_prefix(u_char * Byte, u_char __user ** fpu_eip,
+static int valid_prefix(u_char *Byte, u_char __user ** fpu_eip,
 			overrides * override);
 
 asmlinkage void math_emulate(long arg)
@@ -580,7 +580,7 @@ asmlinkage void math_emulate(long arg)
    all prefix bytes, further changes are needed in the emulator code
    which accesses user address space. Access to separate segments is
    important for msdos emulation. */
-static int valid_prefix(u_char * Byte, u_char __user ** fpu_eip,
+static int valid_prefix(u_char *Byte, u_char __user **fpu_eip,
 			overrides * override)
 {
 	u_char byte;
@@ -673,7 +673,7 @@ void math_abort(struct info *info, unsigned int signal)
 #define sstatus_word() \
   ((S387->swd & ~SW_Top & 0xffff) | ((S387->ftop << SW_Top_Shift) & SW_Top))
 
-int restore_i387_soft(void *s387, struct _fpstate __user * buf)
+int restore_i387_soft(void *s387, struct _fpstate __user *buf)
 {
 	u_char __user *d = (u_char __user *) buf;
 	int offset, other, i, tags, regnr, tag, newtop;
diff --git a/arch/x86/math-emu/fpu_etc.c b/arch/x86/math-emu/fpu_etc.c
index e73631e0cde9..233e5af566f5 100644
--- a/arch/x86/math-emu/fpu_etc.c
+++ b/arch/x86/math-emu/fpu_etc.c
@@ -16,7 +16,7 @@
 #include "status_w.h"
 #include "reg_constant.h"
 
-static void fchs(FPU_REG * st0_ptr, u_char st0tag)
+static void fchs(FPU_REG *st0_ptr, u_char st0tag)
 {
 	if (st0tag ^ TAG_Empty) {
 		signbyte(st0_ptr) ^= SIGN_NEG;
@@ -25,7 +25,7 @@ static void fchs(FPU_REG * st0_ptr, u_char st0tag)
 		FPU_stack_underflow();
 }
 
-static void fabs(FPU_REG * st0_ptr, u_char st0tag)
+static void fabs(FPU_REG *st0_ptr, u_char st0tag)
 {
 	if (st0tag ^ TAG_Empty) {
 		setpositive(st0_ptr);
@@ -34,7 +34,7 @@ static void fabs(FPU_REG * st0_ptr, u_char st0tag)
 		FPU_stack_underflow();
 }
 
-static void ftst_(FPU_REG * st0_ptr, u_char st0tag)
+static void ftst_(FPU_REG *st0_ptr, u_char st0tag)
 {
 	switch (st0tag) {
 	case TAG_Zero:
@@ -85,7 +85,7 @@ static void ftst_(FPU_REG * st0_ptr, u_char st0tag)
 	}
 }
 
-static void fxam(FPU_REG * st0_ptr, u_char st0tag)
+static void fxam(FPU_REG *st0_ptr, u_char st0tag)
 {
 	int c = 0;
 	switch (st0tag) {
diff --git a/arch/x86/math-emu/fpu_proto.h b/arch/x86/math-emu/fpu_proto.h
index 0f6384102afd..aa49b6a0d850 100644
--- a/arch/x86/math-emu/fpu_proto.h
+++ b/arch/x86/math-emu/fpu_proto.h
@@ -5,7 +5,7 @@
 extern void FPU_illegal(void);
 extern void FPU_printall(void);
 asmlinkage void FPU_exception(int n);
-extern int real_1op_NaN(FPU_REG * a);
+extern int real_1op_NaN(FPU_REG *a);
 extern int real_2op_NaN(FPU_REG const *b, u_char tagb, int deststnr,
 			FPU_REG const *defaultNaN);
 asmlinkage int arith_invalid(int deststnr);
@@ -14,8 +14,8 @@ extern int set_precision_flag(int flags);
 asmlinkage void set_precision_flag_up(void);
 asmlinkage void set_precision_flag_down(void);
 asmlinkage int denormal_operand(void);
-asmlinkage int arith_overflow(FPU_REG * dest);
-asmlinkage int arith_underflow(FPU_REG * dest);
+asmlinkage int arith_overflow(FPU_REG *dest);
+asmlinkage int arith_underflow(FPU_REG *dest);
 extern void FPU_stack_overflow(void);
 extern void FPU_stack_underflow(void);
 extern void FPU_stack_underflow_i(int i);
@@ -84,19 +84,19 @@ extern void __user *FPU_get_address_16(u_char FPU_modrm, unsigned long *fpu_eip,
 extern int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
 			  void __user * data_address);
 /* poly_2xm1.c */
-extern int poly_2xm1(u_char sign, FPU_REG * arg, FPU_REG * result);
+extern int poly_2xm1(u_char sign, FPU_REG * arg, FPU_REG *result);
 /* poly_atan.c */
-extern void poly_atan(FPU_REG * st0_ptr, u_char st0_tag, FPU_REG * st1_ptr,
+extern void poly_atan(FPU_REG * st0_ptr, u_char st0_tag, FPU_REG *st1_ptr,
 		      u_char st1_tag);
 /* poly_l2.c */
-extern void poly_l2(FPU_REG * st0_ptr, FPU_REG * st1_ptr, u_char st1_sign);
-extern int poly_l2p1(u_char s0, u_char s1, FPU_REG * r0, FPU_REG * r1,
+extern void poly_l2(FPU_REG *st0_ptr, FPU_REG *st1_ptr, u_char st1_sign);
+extern int poly_l2p1(u_char s0, u_char s1, FPU_REG *r0, FPU_REG *r1,
 		     FPU_REG * d);
 /* poly_sin.c */
-extern void poly_sine(FPU_REG * st0_ptr);
-extern void poly_cos(FPU_REG * st0_ptr);
+extern void poly_sine(FPU_REG *st0_ptr);
+extern void poly_cos(FPU_REG *st0_ptr);
 /* poly_tan.c */
-extern void poly_tan(FPU_REG * st0_ptr);
+extern void poly_tan(FPU_REG *st0_ptr);
 /* reg_add_sub.c */
 extern int FPU_add(FPU_REG const *b, u_char tagb, int destrnr, int control_w);
 extern int FPU_sub(int flags, int rm, int control_w);
@@ -111,34 +111,34 @@ extern void fucompp(void);
 /* reg_constant.c */
 extern void fconst(void);
 /* reg_ld_str.c */
-extern int FPU_load_extended(long double __user * s, int stnr);
-extern int FPU_load_double(double __user * dfloat, FPU_REG * loaded_data);
-extern int FPU_load_single(float __user * single, FPU_REG * loaded_data);
-extern int FPU_load_int64(long long __user * _s);
-extern int FPU_load_int32(long __user * _s, FPU_REG * loaded_data);
-extern int FPU_load_int16(short __user * _s, FPU_REG * loaded_data);
-extern int FPU_load_bcd(u_char __user * s);
-extern int FPU_store_extended(FPU_REG * st0_ptr, u_char st0_tag,
+extern int FPU_load_extended(long double __user *s, int stnr);
+extern int FPU_load_double(double __user *dfloat, FPU_REG *loaded_data);
+extern int FPU_load_single(float __user *single, FPU_REG *loaded_data);
+extern int FPU_load_int64(long long __user *_s);
+extern int FPU_load_int32(long __user *_s, FPU_REG *loaded_data);
+extern int FPU_load_int16(short __user *_s, FPU_REG *loaded_data);
+extern int FPU_load_bcd(u_char __user *s);
+extern int FPU_store_extended(FPU_REG *st0_ptr, u_char st0_tag,
 			      long double __user * d);
-extern int FPU_store_double(FPU_REG * st0_ptr, u_char st0_tag,
+extern int FPU_store_double(FPU_REG *st0_ptr, u_char st0_tag,
 			    double __user * dfloat);
-extern int FPU_store_single(FPU_REG * st0_ptr, u_char st0_tag,
+extern int FPU_store_single(FPU_REG *st0_ptr, u_char st0_tag,
 			    float __user * single);
-extern int FPU_store_int64(FPU_REG * st0_ptr, u_char st0_tag,
+extern int FPU_store_int64(FPU_REG *st0_ptr, u_char st0_tag,
 			   long long __user * d);
-extern int FPU_store_int32(FPU_REG * st0_ptr, u_char st0_tag, long __user * d);
-extern int FPU_store_int16(FPU_REG * st0_ptr, u_char st0_tag, short __user * d);
-extern int FPU_store_bcd(FPU_REG * st0_ptr, u_char st0_tag, u_char __user * d);
-extern int FPU_round_to_int(FPU_REG * r, u_char tag);
-extern u_char __user *fldenv(fpu_addr_modes addr_modes, u_char __user * s);
-extern void frstor(fpu_addr_modes addr_modes, u_char __user * data_address);
-extern u_char __user *fstenv(fpu_addr_modes addr_modes, u_char __user * d);
-extern void fsave(fpu_addr_modes addr_modes, u_char __user * data_address);
-extern int FPU_tagof(FPU_REG * ptr);
+extern int FPU_store_int32(FPU_REG *st0_ptr, u_char st0_tag, long __user *d);
+extern int FPU_store_int16(FPU_REG *st0_ptr, u_char st0_tag, short __user *d);
+extern int FPU_store_bcd(FPU_REG *st0_ptr, u_char st0_tag, u_char __user *d);
+extern int FPU_round_to_int(FPU_REG *r, u_char tag);
+extern u_char __user *fldenv(fpu_addr_modes addr_modes, u_char __user *s);
+extern void frstor(fpu_addr_modes addr_modes, u_char __user *data_address);
+extern u_char __user *fstenv(fpu_addr_modes addr_modes, u_char __user *d);
+extern void fsave(fpu_addr_modes addr_modes, u_char __user *data_address);
+extern int FPU_tagof(FPU_REG *ptr);
 /* reg_mul.c */
 extern int FPU_mul(FPU_REG const *b, u_char tagb, int deststnr, int control_w);
 
 extern int FPU_div(int flags, int regrm, int control_w);
 /* reg_convert.c */
-extern int FPU_to_exp16(FPU_REG const *a, FPU_REG * x);
+extern int FPU_to_exp16(FPU_REG const *a, FPU_REG *x);
 #endif /* _FPU_PROTO_H */
diff --git a/arch/x86/math-emu/fpu_trig.c b/arch/x86/math-emu/fpu_trig.c
index e5316a288a6e..ecd06680581c 100644
--- a/arch/x86/math-emu/fpu_trig.c
+++ b/arch/x86/math-emu/fpu_trig.c
@@ -30,7 +30,7 @@ static void rem_kernel(unsigned long long st0, unsigned long long *y,
 /* Limited measurements show no results worse than 64 bit precision
    except for the results for arguments close to 2^63, where the
    precision of the result sometimes degrades to about 63.9 bits */
-static int trig_arg(FPU_REG * st0_ptr, int even)
+static int trig_arg(FPU_REG *st0_ptr, int even)
 {
 	FPU_REG tmp;
 	u_char tmptag;
@@ -176,7 +176,7 @@ static void convert_l2reg(long const *arg, int deststnr)
 	return;
 }
 
-static void single_arg_error(FPU_REG * st0_ptr, u_char st0_tag)
+static void single_arg_error(FPU_REG *st0_ptr, u_char st0_tag)
 {
 	if (st0_tag == TAG_Empty)
 		FPU_stack_underflow();	/* Puts a QNaN in st(0) */
@@ -188,7 +188,7 @@ static void single_arg_error(FPU_REG * st0_ptr, u_char st0_tag)
 #endif /* PARANOID */
 }
 
-static void single_arg_2_error(FPU_REG * st0_ptr, u_char st0_tag)
+static void single_arg_2_error(FPU_REG *st0_ptr, u_char st0_tag)
 {
 	int isNaN;
 
@@ -229,7 +229,7 @@ static void single_arg_2_error(FPU_REG * st0_ptr, u_char st0_tag)
 
 /*---------------------------------------------------------------------------*/
 
-static void f2xm1(FPU_REG * st0_ptr, u_char tag)
+static void f2xm1(FPU_REG *st0_ptr, u_char tag)
 {
 	FPU_REG a;
 
@@ -272,7 +272,7 @@ static void f2xm1(FPU_REG * st0_ptr, u_char tag)
 	}
 }
 
-static void fptan(FPU_REG * st0_ptr, u_char st0_tag)
+static void fptan(FPU_REG *st0_ptr, u_char st0_tag)
 {
 	FPU_REG *st_new_ptr;
 	int q;
@@ -351,7 +351,7 @@ static void fptan(FPU_REG * st0_ptr, u_char st0_tag)
 	single_arg_2_error(st0_ptr, st0_tag);
 }
 
-static void fxtract(FPU_REG * st0_ptr, u_char st0_tag)
+static void fxtract(FPU_REG *st0_ptr, u_char st0_tag)
 {
 	FPU_REG *st_new_ptr;
 	u_char sign;
@@ -444,7 +444,7 @@ static void fincstp(void)
 	top++;
 }
 
-static void fsqrt_(FPU_REG * st0_ptr, u_char st0_tag)
+static void fsqrt_(FPU_REG *st0_ptr, u_char st0_tag)
 {
 	int expon;
 
@@ -502,7 +502,7 @@ static void fsqrt_(FPU_REG * st0_ptr, u_char st0_tag)
 
 }
 
-static void frndint_(FPU_REG * st0_ptr, u_char st0_tag)
+static void frndint_(FPU_REG *st0_ptr, u_char st0_tag)
 {
 	int flags, tag;
 
@@ -546,7 +546,7 @@ static void frndint_(FPU_REG * st0_ptr, u_char st0_tag)
 		single_arg_error(st0_ptr, st0_tag);
 }
 
-static int fsin(FPU_REG * st0_ptr, u_char tag)
+static int fsin(FPU_REG *st0_ptr, u_char tag)
 {
 	u_char arg_sign = getsign(st0_ptr);
 
@@ -607,7 +607,7 @@ static int fsin(FPU_REG * st0_ptr, u_char tag)
 	}
 }
 
-static int f_cos(FPU_REG * st0_ptr, u_char tag)
+static int f_cos(FPU_REG *st0_ptr, u_char tag)
 {
 	u_char st0_sign;
 
@@ -677,12 +677,12 @@ static int f_cos(FPU_REG * st0_ptr, u_char tag)
 	}
 }
 
-static void fcos(FPU_REG * st0_ptr, u_char st0_tag)
+static void fcos(FPU_REG *st0_ptr, u_char st0_tag)
 {
 	f_cos(st0_ptr, st0_tag);
 }
 
-static void fsincos(FPU_REG * st0_ptr, u_char st0_tag)
+static void fsincos(FPU_REG *st0_ptr, u_char st0_tag)
 {
 	FPU_REG *st_new_ptr;
 	FPU_REG arg;
@@ -775,7 +775,7 @@ static void rem_kernel(unsigned long long st0, unsigned long long *y,
 /* Remainder of st(0) / st(1) */
 /* This routine produces exact results, i.e. there is never any
    rounding or truncation, etc of the result. */
-static void do_fprem(FPU_REG * st0_ptr, u_char st0_tag, int round)
+static void do_fprem(FPU_REG *st0_ptr, u_char st0_tag, int round)
 {
 	FPU_REG *st1_ptr = &st(1);
 	u_char st1_tag = FPU_gettagi(1);
@@ -1017,7 +1017,7 @@ static void do_fprem(FPU_REG * st0_ptr, u_char st0_tag, int round)
 }
 
 /* ST(1) <- ST(1) * log ST;  pop ST */
-static void fyl2x(FPU_REG * st0_ptr, u_char st0_tag)
+static void fyl2x(FPU_REG *st0_ptr, u_char st0_tag)
 {
 	FPU_REG *st1_ptr = &st(1), exponent;
 	u_char st1_tag = FPU_gettagi(1);
@@ -1188,7 +1188,7 @@ static void fyl2x(FPU_REG * st0_ptr, u_char st0_tag)
 	FPU_pop();
 }
 
-static void fpatan(FPU_REG * st0_ptr, u_char st0_tag)
+static void fpatan(FPU_REG *st0_ptr, u_char st0_tag)
 {
 	FPU_REG *st1_ptr = &st(1);
 	u_char st1_tag = FPU_gettagi(1);
@@ -1298,17 +1298,17 @@ static void fpatan(FPU_REG * st0_ptr, u_char st0_tag)
 	set_precision_flag_up();	/* We do not really know if up or down */
 }
 
-static void fprem(FPU_REG * st0_ptr, u_char st0_tag)
+static void fprem(FPU_REG *st0_ptr, u_char st0_tag)
 {
 	do_fprem(st0_ptr, st0_tag, RC_CHOP);
 }
 
-static void fprem1(FPU_REG * st0_ptr, u_char st0_tag)
+static void fprem1(FPU_REG *st0_ptr, u_char st0_tag)
 {
 	do_fprem(st0_ptr, st0_tag, RC_RND);
 }
 
-static void fyl2xp1(FPU_REG * st0_ptr, u_char st0_tag)
+static void fyl2xp1(FPU_REG *st0_ptr, u_char st0_tag)
 {
 	u_char sign, sign1;
 	FPU_REG *st1_ptr = &st(1), a, b;
@@ -1477,7 +1477,7 @@ static void fyl2xp1(FPU_REG * st0_ptr, u_char st0_tag)
 
 }
 
-static void fscale(FPU_REG * st0_ptr, u_char st0_tag)
+static void fscale(FPU_REG *st0_ptr, u_char st0_tag)
 {
 	FPU_REG *st1_ptr = &st(1);
 	u_char st1_tag = FPU_gettagi(1);
diff --git a/arch/x86/math-emu/poly.h b/arch/x86/math-emu/poly.h
index f317de7d8864..168eb44c93c8 100644
--- a/arch/x86/math-emu/poly.h
+++ b/arch/x86/math-emu/poly.h
@@ -33,12 +33,12 @@ asmlinkage void polynomial_Xsig(Xsig *, const unsigned long long *x,
 
 asmlinkage void mul32_Xsig(Xsig *, const unsigned long mult);
 asmlinkage void mul64_Xsig(Xsig *, const unsigned long long *mult);
-asmlinkage void mul_Xsig_Xsig(Xsig * dest, const Xsig * mult);
+asmlinkage void mul_Xsig_Xsig(Xsig *dest, const Xsig *mult);
 
 asmlinkage void shr_Xsig(Xsig *, const int n);
 asmlinkage int round_Xsig(Xsig *);
 asmlinkage int norm_Xsig(Xsig *);
-asmlinkage void div_Xsig(Xsig * x1, const Xsig * x2, const Xsig * dest);
+asmlinkage void div_Xsig(Xsig *x1, const Xsig *x2, const Xsig *dest);
 
 /* Macro to extract the most significant 32 bits from a long long */
 #define LL_MSW(x)     (((unsigned long *)&x)[1])
@@ -70,7 +70,7 @@ static inline unsigned long mul_32_32(const unsigned long arg1,
 }
 
 /* Add the 12 byte Xsig x2 to Xsig dest, with no checks for overflow. */
-static inline void add_Xsig_Xsig(Xsig * dest, const Xsig * x2)
+static inline void add_Xsig_Xsig(Xsig *dest, const Xsig *x2)
 {
 	asm volatile ("movl %1,%%edi; movl %2,%%esi;\n"
 		      "movl (%%esi),%%eax; addl %%eax,(%%edi);\n"
@@ -84,7 +84,7 @@ static inline void add_Xsig_Xsig(Xsig * dest, const Xsig * x2)
 /* Note: the constraints in the asm statement didn't always work properly
    with gcc 2.5.8.  Changing from using edi to using ecx got around the
    problem, but keep fingers crossed! */
-static inline void add_two_Xsig(Xsig * dest, const Xsig * x2, long int *exp)
+static inline void add_two_Xsig(Xsig *dest, const Xsig *x2, long int *exp)
 {
 	asm volatile ("movl %2,%%ecx; movl %3,%%esi;\n"
 		      "movl (%%esi),%%eax; addl %%eax,(%%ecx);\n"
@@ -101,7 +101,7 @@ static inline void add_two_Xsig(Xsig * dest, const Xsig * x2, long int *exp)
 
 /* Negate (subtract from 1.0) the 12 byte Xsig */
 /* This is faster in a loop on my 386 than using the "neg" instruction. */
-static inline void negate_Xsig(Xsig * x)
+static inline void negate_Xsig(Xsig *x)
 {
 	asm volatile ("movl %1,%%esi;\n"
 		      "xorl %%ecx,%%ecx;\n"
diff --git a/arch/x86/math-emu/poly_2xm1.c b/arch/x86/math-emu/poly_2xm1.c
index d8f2be3c8383..b00e9e10cdce 100644
--- a/arch/x86/math-emu/poly_2xm1.c
+++ b/arch/x86/math-emu/poly_2xm1.c
@@ -49,7 +49,7 @@ static const Xsig *shiftterm[] = { &shiftterm0, &shiftterm1,
 /*--- poly_2xm1() -----------------------------------------------------------+
  | Requires st(0) which is TAG_Valid and < 1.                                |
  +---------------------------------------------------------------------------*/
-int poly_2xm1(u_char sign, FPU_REG * arg, FPU_REG * result)
+int poly_2xm1(u_char sign, FPU_REG *arg, FPU_REG *result)
 {
 	long int exponent, shift;
 	unsigned long long Xll;
diff --git a/arch/x86/math-emu/poly_atan.c b/arch/x86/math-emu/poly_atan.c
index 2f4ac8143fc3..20c28e58e2d4 100644
--- a/arch/x86/math-emu/poly_atan.c
+++ b/arch/x86/math-emu/poly_atan.c
@@ -48,8 +48,8 @@ static const Xsig pi_signif = MK_XSIG(0xc90fdaa2, 0x2168c234, 0xc4c6628b);
 /*--- poly_atan() -----------------------------------------------------------+
  |                                                                           |
  +---------------------------------------------------------------------------*/
-void poly_atan(FPU_REG * st0_ptr, u_char st0_tag,
-	       FPU_REG * st1_ptr, u_char st1_tag)
+void poly_atan(FPU_REG *st0_ptr, u_char st0_tag,
+	       FPU_REG *st1_ptr, u_char st1_tag)
 {
 	u_char transformed, inverted, sign1, sign2;
 	int exponent;
diff --git a/arch/x86/math-emu/poly_l2.c b/arch/x86/math-emu/poly_l2.c
index c0102ae87511..8e2ff4b28a0a 100644
--- a/arch/x86/math-emu/poly_l2.c
+++ b/arch/x86/math-emu/poly_l2.c
@@ -23,7 +23,7 @@ static void log2_kernel(FPU_REG const *arg, u_char argsign,
 /*--- poly_l2() -------------------------------------------------------------+
  |   Base 2 logarithm by a polynomial approximation.                         |
  +---------------------------------------------------------------------------*/
-void poly_l2(FPU_REG * st0_ptr, FPU_REG * st1_ptr, u_char st1_sign)
+void poly_l2(FPU_REG *st0_ptr, FPU_REG *st1_ptr, u_char st1_sign)
 {
 	long int exponent, expon, expon_expon;
 	Xsig accumulator, expon_accum, yaccum;
@@ -178,7 +178,7 @@ static const unsigned long leadterm = 0xb8000000;
  |   Base 2 logarithm by a polynomial approximation.                         |
  |   log2(x+1)                                                               |
  +---------------------------------------------------------------------------*/
-static void log2_kernel(FPU_REG const *arg, u_char argsign, Xsig * accum_result,
+static void log2_kernel(FPU_REG const *arg, u_char argsign, Xsig *accum_result,
 			long int *expon)
 {
 	long int exponent, adj;
diff --git a/arch/x86/math-emu/poly_sin.c b/arch/x86/math-emu/poly_sin.c
index 7273ae0c7692..b862039c728e 100644
--- a/arch/x86/math-emu/poly_sin.c
+++ b/arch/x86/math-emu/poly_sin.c
@@ -54,7 +54,7 @@ static const unsigned long long neg_terms_h[N_COEFF_NH] = {
 /*--- poly_sine() -----------------------------------------------------------+
  |                                                                           |
  +---------------------------------------------------------------------------*/
-void poly_sine(FPU_REG * st0_ptr)
+void poly_sine(FPU_REG *st0_ptr)
 {
 	int exponent, echange;
 	Xsig accumulator, argSqrd, argTo4;
@@ -197,7 +197,7 @@ void poly_sine(FPU_REG * st0_ptr)
 /*--- poly_cos() ------------------------------------------------------------+
  |                                                                           |
  +---------------------------------------------------------------------------*/
-void poly_cos(FPU_REG * st0_ptr)
+void poly_cos(FPU_REG *st0_ptr)
 {
 	FPU_REG result;
 	long int exponent, exp2, echange;
diff --git a/arch/x86/math-emu/poly_tan.c b/arch/x86/math-emu/poly_tan.c
index c0d181e39229..1875763e0c02 100644
--- a/arch/x86/math-emu/poly_tan.c
+++ b/arch/x86/math-emu/poly_tan.c
@@ -47,7 +47,7 @@ static const unsigned long long twothirds = 0xaaaaaaaaaaaaaaabLL;
 /*--- poly_tan() ------------------------------------------------------------+
  |                                                                           |
  +---------------------------------------------------------------------------*/
-void poly_tan(FPU_REG * st0_ptr)
+void poly_tan(FPU_REG *st0_ptr)
 {
 	long int exponent;
 	int invert;
diff --git a/arch/x86/math-emu/reg_convert.c b/arch/x86/math-emu/reg_convert.c
index afd31b31000d..108060779977 100644
--- a/arch/x86/math-emu/reg_convert.c
+++ b/arch/x86/math-emu/reg_convert.c
@@ -13,7 +13,7 @@
 #include "exception.h"
 #include "fpu_emu.h"
 
-int FPU_to_exp16(FPU_REG const *a, FPU_REG * x)
+int FPU_to_exp16(FPU_REG const *a, FPU_REG *x)
 {
 	int sign = getsign(a);
 
diff --git a/arch/x86/math-emu/reg_ld_str.c b/arch/x86/math-emu/reg_ld_str.c
index 0b2ca8dc2988..799d4af5be66 100644
--- a/arch/x86/math-emu/reg_ld_str.c
+++ b/arch/x86/math-emu/reg_ld_str.c
@@ -35,7 +35,7 @@
 #define SINGLE_Ebias 127
 #define SINGLE_Emin (-126)	/* smallest valid exponent */
 
-static u_char normalize_no_excep(FPU_REG * r, int exp, int sign)
+static u_char normalize_no_excep(FPU_REG *r, int exp, int sign)
 {
 	u_char tag;
 
@@ -49,7 +49,7 @@ static u_char normalize_no_excep(FPU_REG * r, int exp, int sign)
 	return tag;
 }
 
-int FPU_tagof(FPU_REG * ptr)
+int FPU_tagof(FPU_REG *ptr)
 {
 	int exp;
 
@@ -78,7 +78,7 @@ int FPU_tagof(FPU_REG * ptr)
 }
 
 /* Get a long double from user memory */
-int FPU_load_extended(long double __user * s, int stnr)
+int FPU_load_extended(long double __user *s, int stnr)
 {
 	FPU_REG *sti_ptr = &st(stnr);
 
@@ -91,7 +91,7 @@ int FPU_load_extended(long double __user * s, int stnr)
 }
 
 /* Get a double from user memory */
-int FPU_load_double(double __user * dfloat, FPU_REG * loaded_data)
+int FPU_load_double(double __user *dfloat, FPU_REG *loaded_data)
 {
 	int exp, tag, negative;
 	unsigned m64, l64;
@@ -152,7 +152,7 @@ int FPU_load_double(double __user * dfloat, FPU_REG * loaded_data)
 }
 
 /* Get a float from user memory */
-int FPU_load_single(float __user * single, FPU_REG * loaded_data)
+int FPU_load_single(float __user *single, FPU_REG *loaded_data)
 {
 	unsigned m32;
 	int exp, tag, negative;
@@ -206,7 +206,7 @@ int FPU_load_single(float __user * single, FPU_REG * loaded_data)
 }
 
 /* Get a long long from user memory */
-int FPU_load_int64(long long __user * _s)
+int FPU_load_int64(long long __user *_s)
 {
 	long long s;
 	int sign;
@@ -236,7 +236,7 @@ int FPU_load_int64(long long __user * _s)
 }
 
 /* Get a long from user memory */
-int FPU_load_int32(long __user * _s, FPU_REG * loaded_data)
+int FPU_load_int32(long __user *_s, FPU_REG *loaded_data)
 {
 	long s;
 	int negative;
@@ -265,7 +265,7 @@ int FPU_load_int32(long __user * _s, FPU_REG * loaded_data)
 }
 
 /* Get a short from user memory */
-int FPU_load_int16(short __user * _s, FPU_REG * loaded_data)
+int FPU_load_int16(short __user *_s, FPU_REG *loaded_data)
 {
 	int s, negative;
 
@@ -294,7 +294,7 @@ int FPU_load_int16(short __user * _s, FPU_REG * loaded_data)
 }
 
 /* Get a packed bcd array from user memory */
-int FPU_load_bcd(u_char __user * s)
+int FPU_load_bcd(u_char __user *s)
 {
 	FPU_REG *st0_ptr = &st(0);
 	int pos;
@@ -333,7 +333,7 @@ int FPU_load_bcd(u_char __user * s)
 /*===========================================================================*/
 
 /* Put a long double into user memory */
-int FPU_store_extended(FPU_REG * st0_ptr, u_char st0_tag,
+int FPU_store_extended(FPU_REG *st0_ptr, u_char st0_tag,
 		       long double __user * d)
 {
 	/*
@@ -375,7 +375,7 @@ int FPU_store_extended(FPU_REG * st0_ptr, u_char st0_tag,
 }
 
 /* Put a double into user memory */
-int FPU_store_double(FPU_REG * st0_ptr, u_char st0_tag, double __user * dfloat)
+int FPU_store_double(FPU_REG *st0_ptr, u_char st0_tag, double __user *dfloat)
 {
 	unsigned long l[2];
 	unsigned long increment = 0;	/* avoid gcc warnings */
@@ -565,7 +565,7 @@ int FPU_store_double(FPU_REG * st0_ptr, u_char st0_tag, double __user * dfloat)
 }
 
 /* Put a float into user memory */
-int FPU_store_single(FPU_REG * st0_ptr, u_char st0_tag, float __user * single)
+int FPU_store_single(FPU_REG *st0_ptr, u_char st0_tag, float __user *single)
 {
 	long templ = 0;
 	unsigned long increment = 0;	/* avoid gcc warnings */
@@ -754,7 +754,7 @@ int FPU_store_single(FPU_REG * st0_ptr, u_char st0_tag, float __user * single)
 }
 
 /* Put a long long into user memory */
-int FPU_store_int64(FPU_REG * st0_ptr, u_char st0_tag, long long __user * d)
+int FPU_store_int64(FPU_REG *st0_ptr, u_char st0_tag, long long __user *d)
 {
 	FPU_REG t;
 	long long tll;
@@ -804,7 +804,7 @@ int FPU_store_int64(FPU_REG * st0_ptr, u_char st0_tag, long long __user * d)
 }
 
 /* Put a long into user memory */
-int FPU_store_int32(FPU_REG * st0_ptr, u_char st0_tag, long __user * d)
+int FPU_store_int32(FPU_REG *st0_ptr, u_char st0_tag, long __user *d)
 {
 	FPU_REG t;
 	int precision_loss;
@@ -850,7 +850,7 @@ int FPU_store_int32(FPU_REG * st0_ptr, u_char st0_tag, long __user * d)
 }
 
 /* Put a short into user memory */
-int FPU_store_int16(FPU_REG * st0_ptr, u_char st0_tag, short __user * d)
+int FPU_store_int16(FPU_REG *st0_ptr, u_char st0_tag, short __user *d)
 {
 	FPU_REG t;
 	int precision_loss;
@@ -896,7 +896,7 @@ int FPU_store_int16(FPU_REG * st0_ptr, u_char st0_tag, short __user * d)
 }
 
 /* Put a packed bcd array into user memory */
-int FPU_store_bcd(FPU_REG * st0_ptr, u_char st0_tag, u_char __user * d)
+int FPU_store_bcd(FPU_REG *st0_ptr, u_char st0_tag, u_char __user *d)
 {
 	FPU_REG t;
 	unsigned long long ll;
@@ -971,7 +971,7 @@ int FPU_store_bcd(FPU_REG * st0_ptr, u_char st0_tag, u_char __user * d)
 /* Overflow is signalled by a non-zero return value (in eax).
    In the case of overflow, the returned significand always has the
    largest possible value */
-int FPU_round_to_int(FPU_REG * r, u_char tag)
+int FPU_round_to_int(FPU_REG *r, u_char tag)
 {
 	u_char very_big;
 	unsigned eax;
@@ -1028,7 +1028,7 @@ int FPU_round_to_int(FPU_REG * r, u_char tag)
 
 /*===========================================================================*/
 
-u_char __user *fldenv(fpu_addr_modes addr_modes, u_char __user * s)
+u_char __user *fldenv(fpu_addr_modes addr_modes, u_char __user *s)
 {
 	unsigned short tag_word = 0;
 	u_char tag;
@@ -1121,7 +1121,7 @@ u_char __user *fldenv(fpu_addr_modes addr_modes, u_char __user * s)
 	return s;
 }
 
-void frstor(fpu_addr_modes addr_modes, u_char __user * data_address)
+void frstor(fpu_addr_modes addr_modes, u_char __user *data_address)
 {
 	int i, regnr;
 	u_char __user *s = fldenv(addr_modes, data_address);
@@ -1144,7 +1144,7 @@ void frstor(fpu_addr_modes addr_modes, u_char __user * data_address)
 
 }
 
-u_char __user *fstenv(fpu_addr_modes addr_modes, u_char __user * d)
+u_char __user *fstenv(fpu_addr_modes addr_modes, u_char __user *d)
 {
 	if ((addr_modes.default_mode == VM86) ||
 	    ((addr_modes.default_mode == PM16)
@@ -1200,7 +1200,7 @@ u_char __user *fstenv(fpu_addr_modes addr_modes, u_char __user * d)
 	return d;
 }
 
-void fsave(fpu_addr_modes addr_modes, u_char __user * data_address)
+void fsave(fpu_addr_modes addr_modes, u_char __user *data_address)
 {
 	u_char __user *d;
 	int offset = (top & 7) * 10, other = 80 - offset;
-- 
cgit v1.2.3