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/exception.h

@@ -9,7 +9,6 @@
 #ifndef _EXCEPTION_H_
 #define _EXCEPTION_H_
 
-
 #ifdef __ASSEMBLY__
 #define	Const_(x)	$##x
 #else
@@ -34,11 +33,9 @@
 #define EX_Denormal	Const_(0x0002)	/* denormalized operand */
 #define EX_Invalid	Const_(0x0001)	/* invalid operation */
 
-
 #define PRECISION_LOST_UP    Const_((EX_Precision | SW_C1))
 #define PRECISION_LOST_DOWN  Const_(EX_Precision)
 
-
 #ifndef __ASSEMBLY__
 
 #ifdef DEBUG

arch/x86/math-emu/fpu_arith.c

@@ -15,7 +15,6 @@
 #include "control_w.h"
 #include "status_w.h"
 
-
 void fadd__(void)
 {
 	/* fadd st,st(i) */
@@ -24,7 +23,6 @@ void fadd__(void)
 	FPU_add(&st(i), FPU_gettagi(i), 0, control_word);
 }
 
-
 void fmul__(void)
 {
 	/* fmul st,st(i) */
@@ -33,8 +31,6 @@ void fmul__(void)
 	FPU_mul(&st(i), FPU_gettagi(i), 0, control_word);
 }
 
-
-
 void fsub__(void)
 {
 	/* fsub st,st(i) */
@@ -42,7 +38,6 @@ void fsub__(void)
 	FPU_sub(0, FPU_rm, control_word);
 }
 
-
 void fsubr_(void)
 {
 	/* fsubr st,st(i) */
@@ -50,7 +45,6 @@ void fsubr_(void)
 	FPU_sub(REV, FPU_rm, control_word);
 }
 
-
 void fdiv__(void)
 {
 	/* fdiv st,st(i) */
@@ -58,7 +52,6 @@ void fdiv__(void)
 	FPU_div(0, FPU_rm, control_word);
 }
 
-
 void fdivr_(void)
 {
 	/* fdivr st,st(i) */
@@ -66,8 +59,6 @@ void fdivr_(void)
 	FPU_div(REV, FPU_rm, control_word);
 }
 
-
-
 void fadd_i(void)
 {
 	/* fadd st(i),st */
@@ -76,7 +67,6 @@ void fadd_i(void)
 	FPU_add(&st(i), FPU_gettagi(i), i, control_word);
 }
 
-
 void fmul_i(void)
 {
 	/* fmul st(i),st */
@@ -84,7 +74,6 @@ void fmul_i(void)
 	FPU_mul(&st(0), FPU_gettag0(), FPU_rm, control_word);
 }
 
-
 void fsubri(void)
 {
 	/* fsubr st(i),st */
@@ -92,15 +81,13 @@ void fsubri(void)
 	FPU_sub(DEST_RM, FPU_rm, control_word);
 }
 
-
 void fsub_i(void)
 {
 	/* fsub st(i),st */
 	clear_C1();
-  FPU_sub(REV|DEST_RM, FPU_rm, control_word);
+	FPU_sub(REV | DEST_RM, FPU_rm, control_word);
 }
 
-
 void fdivri(void)
 {
 	/* fdivr st(i),st */
@@ -108,67 +95,58 @@ void fdivri(void)
 	FPU_div(DEST_RM, FPU_rm, control_word);
 }
 
-
 void fdiv_i(void)
 {
 	/* fdiv st(i),st */
 	clear_C1();
-  FPU_div(REV|DEST_RM, FPU_rm, control_word);
+	FPU_div(REV | DEST_RM, FPU_rm, control_word);
 }
 
-
-
 void faddp_(void)
 {
 	/* faddp st(i),st */
 	int i = FPU_rm;
 	clear_C1();
-  if ( FPU_add(&st(i), FPU_gettagi(i), i, control_word) >= 0 )
+	if (FPU_add(&st(i), FPU_gettagi(i), i, control_word) >= 0)
 		FPU_pop();
 }
 
-
 void fmulp_(void)
 {
 	/* fmulp st(i),st */
 	clear_C1();
-  if ( FPU_mul(&st(0), FPU_gettag0(), FPU_rm, control_word) >= 0 )
+	if (FPU_mul(&st(0), FPU_gettag0(), FPU_rm, control_word) >= 0)
 		FPU_pop();
 }
 
-
-
 void fsubrp(void)
 {
 	/* fsubrp st(i),st */
 	clear_C1();
-  if ( FPU_sub(DEST_RM, FPU_rm, control_word) >= 0 )
+	if (FPU_sub(DEST_RM, FPU_rm, control_word) >= 0)
 		FPU_pop();
 }
 
-
 void fsubp_(void)
 {
 	/* fsubp st(i),st */
 	clear_C1();
-  if ( FPU_sub(REV|DEST_RM, FPU_rm, control_word) >= 0 )
+	if (FPU_sub(REV | DEST_RM, FPU_rm, control_word) >= 0)
 		FPU_pop();
 }
 
-
 void fdivrp(void)
 {
 	/* fdivrp st(i),st */
 	clear_C1();
-  if ( FPU_div(DEST_RM, FPU_rm, control_word) >= 0 )
+	if (FPU_div(DEST_RM, FPU_rm, control_word) >= 0)
 		FPU_pop();
 }
 
-
 void fdivp_(void)
 {
 	/* fdivp st(i),st */
 	clear_C1();
-  if ( FPU_div(REV|DEST_RM, FPU_rm, control_word) >= 0 )
+	if (FPU_div(REV | DEST_RM, FPU_rm, control_word) >= 0)
 		FPU_pop();
 }

arch/x86/math-emu/fpu_asm.h

@@ -14,7 +14,6 @@
 
 #define	EXCEPTION	FPU_exception
 
-
 #define PARAM1	8(%ebp)
 #define	PARAM2	12(%ebp)
 #define	PARAM3	16(%ebp)

arch/x86/math-emu/fpu_aux.c

@@ -16,15 +16,15 @@
 #include "status_w.h"
 #include "control_w.h"
 
-
 static void fnop(void)
 {
 }
 
 static void fclex(void)
 {
-  partial_status &= ~(SW_Backward|SW_Summary|SW_Stack_Fault|SW_Precision|
-		   SW_Underflow|SW_Overflow|SW_Zero_Div|SW_Denorm_Op|
+	partial_status &=
+	    ~(SW_Backward | SW_Summary | SW_Stack_Fault | SW_Precision |
+	      SW_Underflow | SW_Overflow | SW_Zero_Div | SW_Denorm_Op |
 	      SW_Invalid);
 	no_ip_update = 1;
 }
@@ -60,13 +60,12 @@ static FUNC const finit_table[] = {
 
 void finit_(void)
 {
-  (finit_table[FPU_rm])();
+	(finit_table[FPU_rm]) ();
 }
 
-
 static void fstsw_ax(void)
 {
-  *(short *) &FPU_EAX = status_word();
+	*(short *)&FPU_EAX = status_word();
 	no_ip_update = 1;
 }
 
@@ -77,10 +76,9 @@ static FUNC const fstsw_table[] = {
 
 void fstsw_(void)
 {
-  (fstsw_table[FPU_rm])();
+	(fstsw_table[FPU_rm]) ();
 }
 
-
 static FUNC const fp_nop_table[] = {
 	fnop, FPU_illegal, FPU_illegal, FPU_illegal,
 	FPU_illegal, FPU_illegal, FPU_illegal, FPU_illegal
@@ -88,42 +86,37 @@ static FUNC const fp_nop_table[] = {
 
 void fp_nop(void)
 {
-  (fp_nop_table[FPU_rm])();
+	(fp_nop_table[FPU_rm]) ();
 }
 
-
 void fld_i_(void)
 {
 	FPU_REG *st_new_ptr;
 	int i;
 	u_char tag;
 
-  if ( STACK_OVERFLOW )
-    { FPU_stack_overflow(); return; }
+	if (STACK_OVERFLOW) {
+		FPU_stack_overflow();
+		return;
+	}
 
 	/* fld st(i) */
 	i = FPU_rm;
-  if ( NOT_EMPTY(i) )
-    {
+	if (NOT_EMPTY(i)) {
 		reg_copy(&st(i), st_new_ptr);
 		tag = FPU_gettagi(i);
 		push();
 		FPU_settag0(tag);
-    }
-  else
-    {
-      if ( control_word & CW_Invalid )
-	{
+	} else {
+		if (control_word & CW_Invalid) {
 			/* The masked response */
 			FPU_stack_underflow();
-	}
-      else
+		} else
 			EXCEPTION(EX_StackUnder);
 	}
 
 }
 
-
 void fxch_i(void)
 {
 	/* fxch st(i) */
@@ -132,29 +125,24 @@ void fxch_i(void)
 	FPU_REG *st0_ptr = &st(0), *sti_ptr = &st(i);
 	long tag_word = fpu_tag_word;
 	int regnr = top & 7, regnri = ((regnr + i) & 7);
-  u_char st0_tag = (tag_word >> (regnr*2)) & 3;
-  u_char sti_tag = (tag_word >> (regnri*2)) & 3;
+	u_char st0_tag = (tag_word >> (regnr * 2)) & 3;
+	u_char sti_tag = (tag_word >> (regnri * 2)) & 3;
 
-  if ( st0_tag == TAG_Empty )
-    {
-      if ( sti_tag == TAG_Empty )
-	{
+	if (st0_tag == TAG_Empty) {
+		if (sti_tag == TAG_Empty) {
 			FPU_stack_underflow();
 			FPU_stack_underflow_i(i);
 			return;
 		}
-      if ( control_word & CW_Invalid )
-	{
+		if (control_word & CW_Invalid) {
 			/* Masked response */
 			FPU_copy_to_reg0(sti_ptr, sti_tag);
 		}
 		FPU_stack_underflow_i(i);
 		return;
 	}
-  if ( sti_tag == TAG_Empty )
-    {
-      if ( control_word & CW_Invalid )
-	{
+	if (sti_tag == TAG_Empty) {
+		if (control_word & CW_Invalid) {
 			/* Masked response */
 			FPU_copy_to_regi(st0_ptr, st0_tag, i);
 		}
@@ -167,19 +155,17 @@ void fxch_i(void)
 	reg_copy(sti_ptr, st0_ptr);
 	reg_copy(&t, sti_ptr);
 
-  tag_word &= ~(3 << (regnr*2)) & ~(3 << (regnri*2));
-  tag_word |= (sti_tag << (regnr*2)) | (st0_tag << (regnri*2));
+	tag_word &= ~(3 << (regnr * 2)) & ~(3 << (regnri * 2));
+	tag_word |= (sti_tag << (regnr * 2)) | (st0_tag << (regnri * 2));
 	fpu_tag_word = tag_word;
 }
 
-
 void ffree_(void)
 {
 	/* ffree st(i) */
 	FPU_settagi(FPU_rm, TAG_Empty);
 }
 
-
 void ffreep(void)
 {
 	/* ffree st(i) + pop - unofficial code */
@@ -187,18 +173,15 @@ void ffreep(void)
 	FPU_pop();
 }
 
-
 void fst_i_(void)
 {
 	/* fst st(i) */
 	FPU_copy_to_regi(&st(0), FPU_gettag0(), FPU_rm);
 }
 
-
 void fstp_i(void)
 {
 	/* fstp st(i) */
 	FPU_copy_to_regi(&st(0), FPU_gettag0(), FPU_rm);
 	FPU_pop();
 }
-

arch/x86/math-emu/fpu_emu.h

@@ -7,7 +7,6 @@
  |                                                                           |
  +---------------------------------------------------------------------------*/
 
-
 #ifndef _FPU_EMU_H_
 #define _FPU_EMU_H_
 
@@ -44,7 +43,6 @@
 #define SIGN_Positive	Const(0)
 #define SIGN_Negative	Const(0x8000)
 
-
 /* Keep the order TAG_Valid, TAG_Zero, TW_Denormal */
 /* The following fold to 2 (Special) in the Tag Word */
 #define TW_Denormal     Const(4)	/* De-normal */
@@ -69,7 +67,6 @@
 
 #define FPU_Exception   Const(0x80000000)	/* Added to tag returns. */
 
-
 #ifndef __ASSEMBLY__
 
 #include "fpu_system.h"
@@ -123,14 +120,17 @@ struct fpu__reg {
 	short exp;
 };
 
-typedef void (*FUNC)(void);
+typedef void (*FUNC) (void);
 typedef struct fpu__reg FPU_REG;
-typedef void (*FUNC_ST0)(FPU_REG *st0_ptr, u_char st0_tag);
-typedef struct { u_char address_size, operand_size, segment; }
-        overrides;
+typedef void (*FUNC_ST0) (FPU_REG * st0_ptr, u_char st0_tag);
+typedef struct {
+	u_char address_size, operand_size, segment;
+} overrides;
 /* This structure is 32 bits: */
-typedef struct { overrides override;
-		 u_char default_mode; } fpu_addr_modes;
+typedef struct {
+	overrides override;
+	u_char default_mode;
+} fpu_addr_modes;
 /* PROTECTED has a restricted meaning in the emulator; it is used
    to signal that the emulator needs to do special things to ensure
    that protection is respected in a segmented model. */
@@ -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);
@@ -184,29 +184,28 @@ static inline void reg_copy(FPU_REG const *x, FPU_REG *y)
 
 #define significand(x) ( ((unsigned long long *)&((x)->sigl))[0] )
 
-
 /*----- 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,
+			 FPU_REG * answ, unsigned int control_w, u_char sign,
 			 int expa, int expb);
 asmlinkage int FPU_u_mul(FPU_REG const *arg1, FPU_REG const *arg2,
-			 FPU_REG *answ, unsigned int control_w, u_char sign,
+			 FPU_REG * answ, unsigned int control_w, u_char sign,
 			 int expon);
 asmlinkage int FPU_u_div(FPU_REG const *arg1, FPU_REG const *arg2,
-			 FPU_REG *answ, unsigned int control_w, u_char sign);
+			 FPU_REG * answ, unsigned int control_w, u_char sign);
 asmlinkage int FPU_u_add(FPU_REG const *arg1, FPU_REG const *arg2,
-			 FPU_REG *answ, unsigned int control_w, u_char sign,
+			 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

arch/x86/math-emu/fpu_etc.c

@@ -16,35 +16,27 @@
 #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 )
-    {
+	if (st0tag ^ TAG_Empty) {
 		signbyte(st0_ptr) ^= SIGN_NEG;
 		clear_C1();
-    }
-  else
+	} else
 		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 )
-    {
+	if (st0tag ^ TAG_Empty) {
 		setpositive(st0_ptr);
 		clear_C1();
-    }
-  else
+	} else
 		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)
-    {
+	switch (st0tag) {
 	case TAG_Zero:
 		setcc(SW_C3);
 		break;
@@ -55,15 +47,13 @@ static void ftst_(FPU_REG *st0_ptr, u_char st0tag)
 			setcc(SW_C0);
 		break;
 	case TAG_Special:
-      switch ( FPU_Special(st0_ptr) )
-	{
+		switch (FPU_Special(st0_ptr)) {
 		case TW_Denormal:
 			if (getsign(st0_ptr) == SIGN_POS)
 				setcc(0);
 			else
 				setcc(SW_C0);
-	  if ( denormal_operand() < 0 )
-	    {
+			if (denormal_operand() < 0) {
 #ifdef PECULIAR_486
 				/* This is weird! */
 				if (getsign(st0_ptr) == SIGN_POS)
@@ -73,7 +63,7 @@ static void ftst_(FPU_REG *st0_ptr, u_char st0tag)
 			}
 			break;
 		case TW_NaN:
-	  setcc(SW_C0|SW_C2|SW_C3);   /* Operand is not comparable */ 
+			setcc(SW_C0 | SW_C2 | SW_C3);	/* Operand is not comparable */
 			EXCEPTION(EX_Invalid);
 			break;
 		case TW_Infinity:
@@ -83,26 +73,24 @@ static void ftst_(FPU_REG *st0_ptr, u_char st0tag)
 				setcc(SW_C0);
 			break;
 		default:
-	  setcc(SW_C0|SW_C2|SW_C3);   /* Operand is not comparable */ 
-	  EXCEPTION(EX_INTERNAL|0x14);
+			setcc(SW_C0 | SW_C2 | SW_C3);	/* Operand is not comparable */
+			EXCEPTION(EX_INTERNAL | 0x14);
 			break;
 		}
 		break;
 	case TAG_Empty:
-      setcc(SW_C0|SW_C2|SW_C3);
+		setcc(SW_C0 | SW_C2 | SW_C3);
 		EXCEPTION(EX_StackUnder);
 		break;
 	}
 }
 
-
-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)
-    {
+	switch (st0tag) {
 	case TAG_Empty:
-      c = SW_C3|SW_C0;
+		c = SW_C3 | SW_C0;
 		break;
 	case TAG_Zero:
 		c = SW_C3;
@@ -111,33 +99,32 @@ static void fxam(FPU_REG *st0_ptr, u_char st0tag)
 		c = SW_C2;
 		break;
 	case TAG_Special:
-      switch ( FPU_Special(st0_ptr) )
-	{
+		switch (FPU_Special(st0_ptr)) {
 		case TW_Denormal:
-	  c = SW_C2|SW_C3;  /* Denormal */
+			c = SW_C2 | SW_C3;	/* Denormal */
 			break;
 		case TW_NaN:
 			/* We also use NaN for unsupported types. */
-	  if ( (st0_ptr->sigh & 0x80000000) && (exponent(st0_ptr) == EXP_OVER) )
+			if ((st0_ptr->sigh & 0x80000000)
+			    && (exponent(st0_ptr) == EXP_OVER))
 				c = SW_C0;
 			break;
 		case TW_Infinity:
-	  c = SW_C2|SW_C0;
+			c = SW_C2 | SW_C0;
 			break;
 		}
 	}
-  if ( getsign(st0_ptr) == SIGN_NEG )
+	if (getsign(st0_ptr) == SIGN_NEG)
 		c |= SW_C1;
 	setcc(c);
 }
 
-
 static FUNC_ST0 const fp_etc_table[] = {
-  fchs, fabs, (FUNC_ST0)FPU_illegal, (FUNC_ST0)FPU_illegal,
-  ftst_, fxam, (FUNC_ST0)FPU_illegal, (FUNC_ST0)FPU_illegal
+	fchs, fabs, (FUNC_ST0) FPU_illegal, (FUNC_ST0) FPU_illegal,
+	ftst_, fxam, (FUNC_ST0) FPU_illegal, (FUNC_ST0) FPU_illegal
 };
 
 void FPU_etc(void)
 {
-  (fp_etc_table[FPU_rm])(&st(0), FPU_gettag0());
+	(fp_etc_table[FPU_rm]) (&st(0), FPU_gettag0());
 }

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);
@@ -66,7 +66,7 @@ extern int FPU_Special(FPU_REG const *ptr);
 extern int isNaN(FPU_REG const *ptr);
 extern void FPU_pop(void);
 extern int FPU_empty_i(int stnr);
-extern int FPU_stackoverflow(FPU_REG **st_new_ptr);
+extern int FPU_stackoverflow(FPU_REG ** st_new_ptr);
 extern void FPU_copy_to_regi(FPU_REG const *r, u_char tag, int stnr);
 extern void FPU_copy_to_reg1(FPU_REG const *r, u_char tag);
 extern void FPU_copy_to_reg0(FPU_REG const *r, u_char tag);
@@ -75,26 +75,28 @@ extern void FPU_triga(void);
 extern void FPU_trigb(void);
 /* get_address.c */
 extern void __user *FPU_get_address(u_char FPU_modrm, unsigned long *fpu_eip,
-			 struct address *addr, fpu_addr_modes addr_modes);
+				    struct address *addr,
+				    fpu_addr_modes addr_modes);
 extern void __user *FPU_get_address_16(u_char FPU_modrm, unsigned long *fpu_eip,
-			    struct address *addr, fpu_addr_modes addr_modes);
+				       struct address *addr,
+				       fpu_addr_modes addr_modes);
 /* load_store.c */
 extern int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
-			    void __user *data_address);
+			  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,
-		     FPU_REG *d);
+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);
@@ -109,32 +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,
-			      long double __user *d);
-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, float __user *single);
-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_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,
+			    double __user * dfloat);
+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,
+			   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);
 /* 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 */
-

arch/x86/math-emu/fpu_tags.c

@@ -14,95 +14,83 @@
 #include "fpu_system.h"
 #include "exception.h"
 
-
 void FPU_pop(void)
 {
-  fpu_tag_word |= 3 << ((top & 7)*2);
+	fpu_tag_word |= 3 << ((top & 7) * 2);
 	top++;
 }
 
-
 int FPU_gettag0(void)
 {
-  return (fpu_tag_word >> ((top & 7)*2)) & 3;
+	return (fpu_tag_word >> ((top & 7) * 2)) & 3;
 }
 
-
 int FPU_gettagi(int stnr)
 {
-  return (fpu_tag_word >> (((top+stnr) & 7)*2)) & 3;
+	return (fpu_tag_word >> (((top + stnr) & 7) * 2)) & 3;
 }
 
-
 int FPU_gettag(int regnr)
 {
-  return (fpu_tag_word >> ((regnr & 7)*2)) & 3;
+	return (fpu_tag_word >> ((regnr & 7) * 2)) & 3;
 }
 
-
 void FPU_settag0(int tag)
 {
 	int regnr = top;
 	regnr &= 7;
-  fpu_tag_word &= ~(3 << (regnr*2));
-  fpu_tag_word |= (tag & 3) << (regnr*2);
+	fpu_tag_word &= ~(3 << (regnr * 2));
+	fpu_tag_word |= (tag & 3) << (regnr * 2);
 }
 
-
 void FPU_settagi(int stnr, int tag)
 {
-  int regnr = stnr+top;
+	int regnr = stnr + top;
 	regnr &= 7;
-  fpu_tag_word &= ~(3 << (regnr*2));
-  fpu_tag_word |= (tag & 3) << (regnr*2);
+	fpu_tag_word &= ~(3 << (regnr * 2));
+	fpu_tag_word |= (tag & 3) << (regnr * 2);
 }
 
-
 void FPU_settag(int regnr, int tag)
 {
 	regnr &= 7;
-  fpu_tag_word &= ~(3 << (regnr*2));
-  fpu_tag_word |= (tag & 3) << (regnr*2);
+	fpu_tag_word &= ~(3 << (regnr * 2));
+	fpu_tag_word |= (tag & 3) << (regnr * 2);
 }
 
-
 int FPU_Special(FPU_REG const *ptr)
 {
 	int exp = exponent(ptr);
 
-  if ( exp == EXP_BIAS+EXP_UNDER )
+	if (exp == EXP_BIAS + EXP_UNDER)
 		return TW_Denormal;
-  else if ( exp != EXP_BIAS+EXP_OVER )
+	else if (exp != EXP_BIAS + EXP_OVER)
 		return TW_NaN;
-  else if ( (ptr->sigh == 0x80000000) && (ptr->sigl == 0) )
+	else if ((ptr->sigh == 0x80000000) && (ptr->sigl == 0))
 		return TW_Infinity;
 	return TW_NaN;
 }
 
-
 int isNaN(FPU_REG const *ptr)
 {
-  return ( (exponent(ptr) == EXP_BIAS+EXP_OVER)
-	   && !((ptr->sigh == 0x80000000) && (ptr->sigl == 0)) );
+	return ((exponent(ptr) == EXP_BIAS + EXP_OVER)
+		&& !((ptr->sigh == 0x80000000) && (ptr->sigl == 0)));
 }
 
-
 int FPU_empty_i(int stnr)
 {
-  int regnr = (top+stnr) & 7;
+	int regnr = (top + stnr) & 7;
 
-  return ((fpu_tag_word >> (regnr*2)) & 3) == TAG_Empty;
+	return ((fpu_tag_word >> (regnr * 2)) & 3) == TAG_Empty;
 }
 
-
-int FPU_stackoverflow(FPU_REG **st_new_ptr)
+int FPU_stackoverflow(FPU_REG ** st_new_ptr)
 {
 	*st_new_ptr = &st(-1);
 
-  return ((fpu_tag_word >> (((top - 1) & 7)*2)) & 3) != TAG_Empty;
+	return ((fpu_tag_word >> (((top - 1) & 7) * 2)) & 3) != TAG_Empty;
 }
 
-
 void FPU_copy_to_regi(FPU_REG const *r, u_char tag, int stnr)
 {
 	reg_copy(r, &st(stnr));
@@ -122,6 +110,6 @@ void FPU_copy_to_reg0(FPU_REG const *r, u_char tag)
 
 	reg_copy(r, &st(0));
 
-  fpu_tag_word &= ~(3 << (regnr*2));
-  fpu_tag_word |= (tag & 3) << (regnr*2);
+	fpu_tag_word &= ~(3 << (regnr * 2));
+	fpu_tag_word |= (tag & 3) << (regnr * 2);
 }

arch/x86/math-emu/load_store.c

@@ -26,7 +26,6 @@
 #include "status_w.h"
 #include "control_w.h"
 
-
 #define _NONE_ 0		/* st0_ptr etc not needed */
 #define _REG0_ 1		/* Will be storing st(0) */
 #define _PUSH_ 3		/* Need to check for space to push onto stack */
@@ -34,7 +33,6 @@
 
 #define pop_0()	{ FPU_settag0(TAG_Empty); top++; }
 
-
 static u_char const type_table[32] = {
 	_PUSH_, _PUSH_, _PUSH_, _PUSH_,
 	_null_, _null_, _null_, _null_,
@@ -44,7 +42,7 @@ static u_char const type_table[32] = {
 	_NONE_, _PUSH_, _null_, _PUSH_,
 	_NONE_, _null_, _NONE_, _REG0_,
 	_NONE_, _REG0_, _NONE_, _REG0_
-  };
+};
 
 u_char const data_sizes_16[32] = {
 	4, 4, 8, 2, 0, 0, 0, 0,
@@ -56,12 +54,12 @@ u_char const data_sizes_16[32] = {
 static u_char const data_sizes_32[32] = {
 	4, 4, 8, 2, 0, 0, 0, 0,
 	4, 4, 8, 2, 4, 4, 8, 2,
-  28, 0,108, 10,  2, 10,  0,  8,  
-  28, 0,108, 10,  2, 10,  2,  8
+	28, 0, 108, 10, 2, 10, 0, 8,
+	28, 0, 108, 10, 2, 10, 2, 8
 };
 
 int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
-		     void __user *data_address)
+		   void __user * data_address)
 {
 	FPU_REG loaded_data;
 	FPU_REG *st0_ptr;
@@ -70,26 +68,21 @@ int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
 
 	st0_ptr = NULL;		/* Initialized just to stop compiler warnings. */
 
-  if ( addr_modes.default_mode & PROTECTED )
-    {
-      if ( addr_modes.default_mode == SEG32 )
-	{
-	  if ( access_limit < data_sizes_32[type] )
-	    math_abort(FPU_info,SIGSEGV);
-	}
-      else if ( addr_modes.default_mode == PM16 )
-	{
-	  if ( access_limit < data_sizes_16[type] )
-	    math_abort(FPU_info,SIGSEGV);
+	if (addr_modes.default_mode & PROTECTED) {
+		if (addr_modes.default_mode == SEG32) {
+			if (access_limit < data_sizes_32[type])
+				math_abort(FPU_info, SIGSEGV);
+		} else if (addr_modes.default_mode == PM16) {
+			if (access_limit < data_sizes_16[type])
+				math_abort(FPU_info, SIGSEGV);
 		}
 #ifdef PARANOID
 		else
-	EXCEPTION(EX_INTERNAL|0x140);
+			EXCEPTION(EX_INTERNAL | 0x140);
 #endif /* PARANOID */
 	}
 
-  switch ( type_table[type] )
-    {
+	switch (type_table[type]) {
 	case _NONE_:
 		break;
 	case _REG0_:
@@ -99,8 +92,10 @@ int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
 		break;
 	case _PUSH_:
 		{
-	if ( FPU_gettagi(-1) != TAG_Empty )
-	  { FPU_stack_overflow(); return 0; }
+			if (FPU_gettagi(-1) != TAG_Empty) {
+				FPU_stack_overflow();
+				return 0;
+			}
 			top--;
 			st0_ptr = &st(0);
 		}
@@ -110,20 +105,19 @@ int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
 		return 0;
 #ifdef PARANOID
 	default:
-      EXCEPTION(EX_INTERNAL|0x141);
+		EXCEPTION(EX_INTERNAL | 0x141);
 		return 0;
 #endif /* PARANOID */
 	}
 
-  switch ( type )
-    {
+	switch (type) {
 	case 000:		/* fld m32real */
 		clear_C1();
-      loaded_tag = FPU_load_single((float __user *)data_address, &loaded_data);
-      if ( (loaded_tag == TAG_Special)
+		loaded_tag =
+		    FPU_load_single((float __user *)data_address, &loaded_data);
+		if ((loaded_tag == TAG_Special)
 		    && isNaN(&loaded_data)
-	   && (real_1op_NaN(&loaded_data) < 0) )
-	{
+		    && (real_1op_NaN(&loaded_data) < 0)) {
 			top++;
 			break;
 		}
@@ -131,16 +125,18 @@ int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
 		break;
 	case 001:		/* fild m32int */
 		clear_C1();
-      loaded_tag = FPU_load_int32((long __user *)data_address, &loaded_data);
+		loaded_tag =
+		    FPU_load_int32((long __user *)data_address, &loaded_data);
 		FPU_copy_to_reg0(&loaded_data, loaded_tag);
 		break;
 	case 002:		/* fld m64real */
 		clear_C1();
-      loaded_tag = FPU_load_double((double __user *)data_address, &loaded_data);
-      if ( (loaded_tag == TAG_Special)
+		loaded_tag =
+		    FPU_load_double((double __user *)data_address,
+				    &loaded_data);
+		if ((loaded_tag == TAG_Special)
 		    && isNaN(&loaded_data)
-	   && (real_1op_NaN(&loaded_data) < 0) )
-	{
+		    && (real_1op_NaN(&loaded_data) < 0)) {
 			top++;
 			break;
 		}
@@ -148,12 +144,14 @@ int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
 		break;
 	case 003:		/* fild m16int */
 		clear_C1();
-      loaded_tag = FPU_load_int16((short __user *)data_address, &loaded_data);
+		loaded_tag =
+		    FPU_load_int16((short __user *)data_address, &loaded_data);
 		FPU_copy_to_reg0(&loaded_data, loaded_tag);
 		break;
 	case 010:		/* fst m32real */
 		clear_C1();
-      FPU_store_single(st0_ptr, st0_tag, (float __user *)data_address);
+		FPU_store_single(st0_ptr, st0_tag,
+				 (float __user *)data_address);
 		break;
 	case 011:		/* fist m32int */
 		clear_C1();
@@ -161,7 +159,8 @@ int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
 		break;
 	case 012:		/* fst m64real */
 		clear_C1();
-      FPU_store_double(st0_ptr, st0_tag, (double __user *)data_address);
+		FPU_store_double(st0_ptr, st0_tag,
+				 (double __user *)data_address);
 		break;
 	case 013:		/* fist m16int */
 		clear_C1();
@@ -169,49 +168,54 @@ int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
 		break;
 	case 014:		/* fstp m32real */
 		clear_C1();
-      if ( FPU_store_single(st0_ptr, st0_tag, (float __user *)data_address) )
+		if (FPU_store_single
+		    (st0_ptr, st0_tag, (float __user *)data_address))
 			pop_0();	/* pop only if the number was actually stored
 					   (see the 80486 manual p16-28) */
 		break;
 	case 015:		/* fistp m32int */
 		clear_C1();
-      if ( FPU_store_int32(st0_ptr, st0_tag, (long __user *)data_address) )
+		if (FPU_store_int32
+		    (st0_ptr, st0_tag, (long __user *)data_address))
 			pop_0();	/* pop only if the number was actually stored
 					   (see the 80486 manual p16-28) */
 		break;
 	case 016:		/* fstp m64real */
 		clear_C1();
-      if ( FPU_store_double(st0_ptr, st0_tag, (double __user *)data_address) )
+		if (FPU_store_double
+		    (st0_ptr, st0_tag, (double __user *)data_address))
 			pop_0();	/* pop only if the number was actually stored
 					   (see the 80486 manual p16-28) */
 		break;
 	case 017:		/* fistp m16int */
 		clear_C1();
-      if ( FPU_store_int16(st0_ptr, st0_tag, (short __user *)data_address) )
+		if (FPU_store_int16
+		    (st0_ptr, st0_tag, (short __user *)data_address))
 			pop_0();	/* pop only if the number was actually stored
 					   (see the 80486 manual p16-28) */
 		break;
 	case 020:		/* fldenv  m14/28byte */
-      fldenv(addr_modes, (u_char __user *)data_address);
+		fldenv(addr_modes, (u_char __user *) data_address);
 		/* Ensure that the values just loaded are not changed by
 		   fix-up operations. */
 		return 1;
 	case 022:		/* frstor m94/108byte */
-      frstor(addr_modes, (u_char __user *)data_address);
+		frstor(addr_modes, (u_char __user *) data_address);
 		/* Ensure that the values just loaded are not changed by
 		   fix-up operations. */
 		return 1;
 	case 023:		/* fbld m80dec */
 		clear_C1();
-      loaded_tag = FPU_load_bcd((u_char __user *)data_address);
+		loaded_tag = FPU_load_bcd((u_char __user *) data_address);
 		FPU_settag0(loaded_tag);
 		break;
 	case 024:		/* fldcw */
 		RE_ENTRANT_CHECK_OFF;
 		FPU_access_ok(VERIFY_READ, data_address, 2);
-      FPU_get_user(control_word, (unsigned short __user *) data_address);
+		FPU_get_user(control_word,
+			     (unsigned short __user *)data_address);
 		RE_ENTRANT_CHECK_ON;
-      if ( partial_status & ~control_word & CW_Exceptions )
+		if (partial_status & ~control_word & CW_Exceptions)
 			partial_status |= (SW_Summary | SW_Backward);
 		else
 			partial_status &= ~(SW_Summary | SW_Backward);
@@ -221,7 +225,8 @@ int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
 		return 1;
 	case 025:		/* fld m80real */
 		clear_C1();
-      loaded_tag = FPU_load_extended((long double __user *)data_address, 0);
+		loaded_tag =
+		    FPU_load_extended((long double __user *)data_address, 0);
 		FPU_settag0(loaded_tag);
 		break;
 	case 027:		/* fild m64int */
@@ -232,38 +237,43 @@ int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
 		FPU_settag0(loaded_tag);
 		break;
 	case 030:		/* fstenv  m14/28byte */
-      fstenv(addr_modes, (u_char __user *)data_address);
+		fstenv(addr_modes, (u_char __user *) data_address);
 		return 1;
 	case 032:		/* fsave */
-      fsave(addr_modes, (u_char __user *)data_address);
+		fsave(addr_modes, (u_char __user *) data_address);
 		return 1;
 	case 033:		/* fbstp m80dec */
 		clear_C1();
-      if ( FPU_store_bcd(st0_ptr, st0_tag, (u_char __user *)data_address) )
+		if (FPU_store_bcd
+		    (st0_ptr, st0_tag, (u_char __user *) data_address))
 			pop_0();	/* pop only if the number was actually stored
 					   (see the 80486 manual p16-28) */
 		break;
 	case 034:		/* fstcw m16int */
 		RE_ENTRANT_CHECK_OFF;
-      FPU_access_ok(VERIFY_WRITE,data_address,2);
-      FPU_put_user(control_word, (unsigned short __user *) data_address);
+		FPU_access_ok(VERIFY_WRITE, data_address, 2);
+		FPU_put_user(control_word,
+			     (unsigned short __user *)data_address);
 		RE_ENTRANT_CHECK_ON;
 		return 1;
 	case 035:		/* fstp m80real */
 		clear_C1();
-      if ( FPU_store_extended(st0_ptr, st0_tag, (long double __user *)data_address) )
+		if (FPU_store_extended
+		    (st0_ptr, st0_tag, (long double __user *)data_address))
 			pop_0();	/* pop only if the number was actually stored
 					   (see the 80486 manual p16-28) */
 		break;
 	case 036:		/* fstsw m2byte */
 		RE_ENTRANT_CHECK_OFF;
-      FPU_access_ok(VERIFY_WRITE,data_address,2);
-      FPU_put_user(status_word(),(unsigned short __user *) data_address);
+		FPU_access_ok(VERIFY_WRITE, data_address, 2);
+		FPU_put_user(status_word(),
+			     (unsigned short __user *)data_address);
 		RE_ENTRANT_CHECK_ON;
 		return 1;
 	case 037:		/* fistp m64int */
 		clear_C1();
-      if ( FPU_store_int64(st0_ptr, st0_tag, (long long __user *)data_address) )
+		if (FPU_store_int64
+		    (st0_ptr, st0_tag, (long long __user *)data_address))
 			pop_0();	/* pop only if the number was actually stored
 					   (see the 80486 manual p16-28) */
 		break;

arch/x86/math-emu/status_w.h

@@ -50,8 +50,8 @@
   ((partial_status & ~SW_Top & 0xffff) | ((top << SW_Top_Shift) & SW_Top))
 static inline void setcc(int cc)
 {
-	partial_status &= ~(SW_C0|SW_C1|SW_C2|SW_C3);
-	partial_status |= (cc) & (SW_C0|SW_C1|SW_C2|SW_C3);
+	partial_status &= ~(SW_C0 | SW_C1 | SW_C2 | SW_C3);
+	partial_status |= (cc) & (SW_C0 | SW_C1 | SW_C2 | SW_C3);
 }
 
 #ifdef PECULIAR_486