WebSVN – tendra.SVN – Diff – /trunk/src/installers/hppa/common/muldvrem.c

+/*
+ * Copyright (c) 2002-2005 The TenDRA Project <http://www.tendra.org/>.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of The TenDRA Project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
 /*
     		 Crown Copyright (c) 1997
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
     acting through the Defence Evaluation and Research Agency
     (DERA).  It is made available to Recipients with a
     royalty-free licence for its use, reproduction, transfer
     to other parties and amendment for any purpose not excluding
     product development provided that any such use et cetera
     shall be deemed to be acceptance of the following conditions:-
 	(1) Its Recipients shall ensure that this Notice is
 	reproduced upon any copies or amended versions of it;
 	(2) Any amended version of it shall be clearly marked to
 	show both the nature of and the organisation responsible
 	for the relevant amendment or amendments;
 	(3) Its onward transfer from a recipient to another
 	party shall be deemed to be that party's acceptance of
 	these conditions;
 	(4) DERA gives no warranty or assurance as to its
 	quality or suitability for any purpose and DERA accepts
 	no liability whatsoever in relation to any use to which
 	it may be put.
 */
  * Revision 3.4  1995/08/25  09:56:26  wfs
  * register synonyms changed. bug fixes to error jump's
+ *
  * Revision 3.1  95/04/10  16:27:27  16:27:27  wfs (William Simmonds)
  * Apr95 tape version.
  *
  * Revision 3.0  95/03/30  11:18:22  11:18:22  wfs (William Simmonds)
  * Mar95 tape version with CRCR95_178 bug fix.
  *
  * Revision 2.0  95/03/15  15:28:11  15:28:11  wfs (William Simmonds)
  * spec 3.1 changes implemented, tests outstanding.
  *
  * Revision 1.3  95/02/02  15:45:02  15:45:02  wfs (William Simmonds)
  * Implemented rem1 and div1.
  *
  * Revision 1.2  95/01/17  17:29:42  17:29:42  wfs (William Simmonds)
  * Changed name of an included header file.
  *
  * Revision 1.1  95/01/11  13:13:34  13:13:34  wfs (William Simmonds)
  * Initial revision
  *
 */
 #define HPPATRANS_CODE
 #include "config.h"
 					 * constant multiply */
 #define NOT_MUL_CONST_SIMPLE	(MAX_MUL_POW2_OFFSET+1)
  /* any constant larger than permissable X offset in 2**n +- X */
-#define IS_POW2(c)		((c) != 0 && ((c) & ((c)-1)) == 0)
+#define IS_POW2(c)		((c)!= 0 && ((c) & ((c) -1)) == 0)
-extern long trap_label PROTO_S ((exp));
+extern long trap_label(exp);
-extern comib_ins PROTO_S ((ins_p,int,int,int));
+extern comib_ins(ins_p,int,int,int);
 /*
  * Utility functions.
  */
 /* return bit number 0..31 from right of word of 'c' which has one bit set */
 static int bit_no
-    PROTO_N ( ( c ) )
-    PROTO_T ( unsigned long c )
+(unsigned long c)
+{
   int shift_const;
   unsigned long mask;
   assert(IS_POW2(c));
   return shift_const;
+}
 void clear_t_regs
-    PROTO_Z ()
+(void)
+{
   /* clear t-regs, i.e. GR2,GR19,GR20..,GR31, which might be modified by a
      call */
   int r;
   clear_reg(GR2);
+  }
+}
 /* call millicode library procedure for complicated operation */
 int call_muldivrem
-    PROTO_N ( ( lhs, rhs, sp, proc ) )
-    PROTO_T ( exp lhs X exp rhs X space sp X int proc )
+(exp lhs, exp rhs, space sp, int proc)
+{
     char *stub="ARGW0=GR ARGW1=GR";
     reg_operand_here(lhs, sp, ARG0);
     sp = needreg(ARG0, sp);
  */
 /* generate code for multiply by constant */
 static void mul_const_complex
-    PROTO_N ( ( src, constval, dest, sp, sgned ) )
-    PROTO_T ( int src X long constval X int dest X space sp X bool sgned )
+(int src, long constval, int dest, space sp, bool sgned)
+{
   struct
+  {
     unsigned char bsl;		/* bit-string of 1s length */
     unsigned char shift;	/* shift from right of word */
+    {
       /*
        * only 2 non overflowing cases to consider 0 * ~0 == 0 1 * ~0 == ~0 ==
        * -1
        *
        * negate handles these two correctly
        */
       rrr_ins(i_sub,c_,0,src,dest);
+    }
     return;
 	bs_tab[bs_tab_len].shift = shift - bsl;	/* .shift is from right */
 	if (bsl == 1)
 	  bsl_1_tab = bs_tab_len;
 	if (bsl > max_bsl)
 	  max_bsl = bsl;
-	comment4("mul_const_complex: bs_tab[%d]=%d,%d c=%d", bs_tab_len, bs_tab[bs_tab_len].bsl, bs_tab[bs_tab_len].shift, c);
+	comment4("mul_const_complex: bs_tab[%d] =%d,%d c=%d", bs_tab_len, bs_tab[bs_tab_len].bsl, bs_tab[bs_tab_len].shift, c);
 	bs_tab_len++;
 	bsl = 0;
+      }
+    }
+  }
 	      tmp_shifted = 0;
 	      found_bsl = 1;
+	    }
 	    if (bs_tab[i].shift != tmp_shifted)
 	    {
 	      int extra_shift = bs_tab[i].shift - tmp_shifted;
 	      assert(extra_shift > 0 && extra_shift <= 31);
 	      rrir_ins(i_shd,c_,tmp,0,32-extra_shift,tmp);
 	      tmp_shifted += extra_shift;
   comment1("end multiply by %ld", constval);
+}
 /* is constval +ve const 2**n or 2**(n +- X) where abs(X) <= MAX_MUL_POW2_OFFSET */
 static int offset_mul_const_simple
-    PROTO_N ( ( constval, sgned ) )
-    PROTO_T ( long constval X bool sgned )
+(long constval, bool sgned)
+{
   int i;
   FULLCOMMENT1("offset_mul_const_simple: %ld", constval);
+}
 /* generate code for multiply by constant */
 static void mul_const_simple
-    PROTO_N ( ( src, constval, dest, sgned ) )
-    PROTO_T ( int src X long constval X int dest X bool sgned )
+(int src, long constval, int dest, bool sgned)
+{
   int shift_const;
   long c;			/* power of two close to constval */
   int add_sub;			/* difference from power of two: +N add, 0
 				 * nop, -N sub */
+    }
     assert(src != inter_reg);
     rrir_ins(i_shd,c_,src,0,32-shift_const,inter_reg);
     if (i_add_sub==i_add)
+    {
        i=1;
        while (i<n)
+       {
 	  if (i+7<n)
+	  {
 	     rrr_ins(i_sh3add,c_,src,inter_reg,inter_reg);
 	     i+=8;
 	  }
 	  else if (i+3<n)
+	  {
 	     rrr_ins(i_sh2add,c_,src,inter_reg,inter_reg);
 	     i+=4;
 	  }
 	  else if (i+1<n)
 	  {
 	     rrr_ins(i_sh1add,c_,src,inter_reg,inter_reg);
 	     i+=2;
 	  }
 	  else
+	  {
 	     rrr_ins(i_add,c_,src,inter_reg,inter_reg);
 	     i++;
 	  }
+       }
+    }
     else
        for (i = 1; i < n; i++)
 	   rrr_ins(i_add_sub,c_,inter_reg,src,inter_reg);
+}
 /* generate code for multiply by constant */
 static void mul_const
-    PROTO_N ( ( src, constval, dest, sp, sgned ) )
-    PROTO_T ( int src X long constval X int dest X space sp X bool sgned )
+(int src, long constval, int dest, space sp, bool sgned)
+{
   if (constval == 0)
      /* rare case not handled by mul_const_X() */
      rr_ins(i_copy,0,dest);
   else if (offset_mul_const_simple(constval, sgned) == NOT_MUL_CONST_SIMPLE)
 /*
  *   Generate code for multiply .
  */
 static int do_mul_comm
-    PROTO_N ( ( e, sp, final_reg, sgned ) )
-    PROTO_T ( exp e X space sp X int final_reg X bool sgned )
+(exp e, space sp, int final_reg, bool sgned)
+{
   exp seq = son(e);
   exp arg2 = bro(seq);
   char *mul_proc;
   int arg = 1;
     seq = bro(seq);
     arg++;
     FULLCOMMENT1("do_mul_comm: name(seq) = %d", name(seq));
-    if (name(seq) == val_tag && offset_mul_const_simple(no(seq), sgned) != NOT_MUL_CONST_SIMPLE)
+    if (name(seq) == val_tag && offset_mul_const_simple(no(seq), sgned)!= NOT_MUL_CONST_SIMPLE)
+    {
       /* const optim */
       assert(last(seq)); /* check() & scan() should move const to last */
       stf_ins(i_fstw,14,b);
       ld_ins(i_lw,SIGNED,b,ARG0);
       if (final_reg == R_NO_REG)
 	 final_reg = RET0;
 	 /* better code from mul_const if src != dest register */
       mul_const(ARG0, no(seq), final_reg, sp, sgned);
       break;
        if (arg==2)
 	  ldf_ins(i_fldd,b,13);
        else
 	  ldf_ins(i_fldw,b,12);
        rrrf_ins(i_xmpyu,f_,12,14,13);
        clear_t_regs();
        if (last(seq))
+       {
 	  stf_ins(i_fstw,14,b);
 	  if (final_reg == R_NO_REG || final_reg == RET0)
+	  {
 	     ld_ins(i_lw,SIGNED,b,RET0);
  	     final_reg = RET0;
+	  }
 	  else
 	     ld_ins(i_lw,SIGNED,b,final_reg);
 	  break;
+       }
 /*
  *   Generate code for div0, div1 and div2 by calling divI or divU unless
  *   dividing by a simple constant.
  */
 static int do_div
-    PROTO_N ( ( e, sp, final_reg, sgned ) )
-    PROTO_T ( exp e X space sp X int final_reg X bool sgned )
+(exp e, space sp, int final_reg, bool sgned)
+{
    exp seq = son(e);
    exp lhs = seq;
    exp rhs = bro(lhs);
    space nsp;
    int trap = 0;
    int sz = shape_size(sh(e));
    char *stub="ARGW0=GR ARGW1=GR";
-   if ( !optop(e) )
+   if (!optop(e))
       trap = trap_label(e);
    assert(last(rhs));
    /*
     *   ov_err can only occur when calculating p div1 q with p == variety's
     *   minimum and q==-1
     */
-   if ( name(rhs)==val_tag )
+   if (name(rhs) ==val_tag)
+   {
       /*   nb. div_by_zero_err handled by common code  */
       int n = no(rhs);
-      if ( n > 0 && IS_POW2(n) )
+      if (n > 0 && IS_POW2(n))
+      {
 	 int lhs_reg = reg_operand(lhs, sp);
 	 int shift_const = bit_no(n);
 	 sp = guardreg(lhs_reg, sp);
-	 if ( final_reg == R_NO_REG )
+	 if (final_reg == R_NO_REG)
+	 {
 	   final_reg = getreg(sp.fixed);
+	 }
-	 if ( n==1)
+	 if (n==1)
+	 {
 	    /*
 	     *   div = lhs
 	     */
  	    rr_ins(i_copy,lhs_reg,final_reg);
 	    return final_reg;
+	 }
 	 else
 	 if (sgned)
+	 {
 	   /* signed, adjust lhs before shift */
  	   assert(shift_const > 0);/* assumed below */
-	   if ( n==-1 && !optop(e) )
+	   if (n==-1 && !optop(e))
+	   {
 	      if (sz==8)
 		 iiir_ins(i_zdepi,c_,-1,24,25,GR1);
 	      else
 	      if (sz==16)
    reg_operand_here(lhs, sp, ARG0);
    nsp = guardreg(ARG0,sp);
    reg_operand_here(rhs,nsp,ARG1);
-   if ( !optop(e) )
+   if (!optop(e))
+   {
       cj_ins(c_eq,GR0,ARG1,trap);
       if (sgned)
+      {
 	 comib_ins(c_neq,-1,ARG1,-16);
 	 z_ins(i_nop);
 	 if (sz==8)
 	    iiir_ins(i_zdepi,c_,-1,24,25,GR1);
 	 else
 	 if (sz==16)
 /*
  *   Generate code for remainder using remI or remU unless  simple constant.
  */
 static int do_rem
-    PROTO_N ( ( e, sp, final_reg, sgned ) )
-    PROTO_T ( exp e X space sp X int final_reg X bool sgned )
+(exp e, space sp, int final_reg, bool sgned)
+{
    exp seq = son(e);
    exp lhs = seq;
    exp rhs = bro(lhs);
    int p=0;
    int trap = 0;
    baseoff b;
    char *stub="ARGW0=GR ARGW1=GR";
    assert(last(rhs));
    b = mem_temp(0);
-   if ( !optop(e) )
+   if (!optop(e))
       trap = trap_label(e);
    if (name(rhs) == val_tag)
+   {
       int n = no(rhs);
-      if ( n==0 )
+      if (n==0)
+      {
-	 if ( !optop(e) )
+	 if (!optop(e))
 	    ub_ins(cmplt_N,trap);
 	 return GR0;
+      }
       else
-      if ( IS_POW2(n) )
+      if (IS_POW2(n))
+      {
 	 int lhs_reg = reg_operand(lhs, sp);
 	 sp = guardreg(lhs_reg, sp);
 	 if (final_reg == R_NO_REG)
+	 {
 	    final_reg = getreg(sp.fixed);
+	 }
 	 if (n == 1)
 	 {
 	    /*
 	     *   rem = 0
 	     */
  	    rr_ins(i_copy,0,final_reg);
 	    return final_reg;
+	 }
-	 while (((1<<(++p)) & n)==0);
+	 while (((1<< (++p)) & n) ==0);
 	 if (sgned && name(bro(rhs)) == rem2_tag)
 	 {
 	    /*
 	     *   Allow for negative lhs. Calculate lhs % n ( = 2**p ) by
 	     *   anding lhs with mask, negating lhs before and after anding
 	     *   if lhs<0.
 	     */
 	    if (lhs_reg==final_reg)
 	 else
+	 {
 	    /*
 	     *   Calculate lhs % n ( = 2**p ) by anding with mask.
 	     */
 	    if (lhs_reg==final_reg)
 	       riir_ins(i_dep,c_,0,31-p,32-p,final_reg);
 	    else
 	       riir_ins(i_zdep,c_,lhs_reg,31,p,final_reg);
+	 }
 	 return final_reg;
 		  else
 		  if (n<0)
 		     rrr_ins(i_comclr,c_leq,RET1,0,0);
 		  ld_ir_ins(i_ldo,cmplt_,fs_,empty_ltrl,n,RET1,RET1);
+	       }
 	       else
+	       {
 		  imm_to_r(n,ARG1);
 		  if (n>0)
 		     rrr_ins(i_comclr,c_geq,RET1,0,0);
 		  else
     *   Need to call remI/.urem
     */
    reg_operand_here(lhs, sp, ARG0);
    nsp = guardreg(ARG0, sp);
    reg_operand_here(rhs, nsp, ARG1);
-   if ( !optop(e) )
+   if (!optop(e))
       cj_ins(c_eq,GR0,ARG1,trap);
    if (name(bro(rhs)) == mod_tag && sgned)
+   {
       st_ins(i_sw,ARG1,b);
       rrr_ins(i_xor,c_geq,RET1,ARG1,0);
       rrr_ins(i_add,c_,RET1,ARG1,RET1);
+   }
    else
+   {
-      call_millicode( sgned ? MILLI_REMI : MILLI_REMU, RP, stub,1 );
+      call_millicode(sgned ? MILLI_REMI : MILLI_REMU, RP, stub,1);
+   }
    clear_t_regs();
    return RET1;  /* result left in RET1 */
+}
-typedef int ( *find_fn ) PROTO_S ( ( exp, space, int, bool ) ) ;
+typedef int(*find_fn)(exp, space, int, bool);
 /* choose regs and generate code using do_fn */
 static int find_reg_and_apply
-    PROTO_N ( ( e, sp, dest, sgned, do_fn ) )
-    PROTO_T ( exp e X space sp X where dest X bool sgned X find_fn do_fn )
+(exp e, space sp, where dest, bool sgned, find_fn do_fn)
+{
   ans a;
   int dest_reg;
   /* +++ mips has tidyshort(dest, sh(e)); check not needed on HPPA */
-  switch (discrim ( dest.answhere ) )
+  switch (discrim(dest.answhere))
+  {
   case inreg:
-    dest_reg = (*do_fn) (e, sp, regalt(dest.answhere), sgned);
+    dest_reg = (*do_fn)(e, sp, regalt(dest.answhere), sgned);
     break;
   case insomereg:
+    {
       int *dr = someregalt(dest.answhere);
+}
 /* choose regs and generate code for multiply using multiply proc */
 int do_mul_comm_op
-    PROTO_N ( ( e, sp, dest, sgned ) )
-    PROTO_T ( exp e X space sp X where dest X bool sgned )
+(exp e, space sp, where dest, bool sgned)
+{
    return find_reg_and_apply(e, sp, dest, sgned, do_mul_comm);
+}
 /* choose regs and generate code for divide using divide proc */
 int do_div_op
-    PROTO_N ( ( e, sp, dest, sgned ) )
-    PROTO_T ( exp e X space sp X where dest X bool sgned )
+(exp e, space sp, where dest, bool sgned)
+{
   return find_reg_and_apply(e, sp, dest, sgned, do_div);
+}
 /* choose regs and generate code for rem using rem proc */
 int do_rem_op
-    PROTO_N ( ( e, sp, dest, sgned ) )
-    PROTO_T ( exp e X space sp X where dest X bool sgned )
+(exp e, space sp, where dest, bool sgned)
+{
   return find_reg_and_apply(e, sp, dest, sgned, do_rem);
+}
 /* is exp mul, div or rem that may call */
 bool is_muldivrem_call
-    PROTO_N ( ( e ) )
-    PROTO_T ( exp e )
+(exp e)
+{
   switch (name(e))
+  {
      case test_tag:
      case chfl_tag:
      case round_tag:
+     {
 	 exp s = son(e);
-	 if ( name(sh(s))==doublehd )
+	 if (name(sh(s)) ==doublehd)
-	    return (1) ;
+	    return(1);
 	 /* FALL THROUGH */
      }
      case fplus_tag:
      case fminus_tag:
      case fmult_tag:
      case fdiv_tag:
      case fneg_tag:
      case fabs_tag:
      case float_tag:
+     {
-	if ( name(sh(e))==doublehd)
+	if (name(sh(e)) ==doublehd)
 	   return(1);
 	else
 	   return(0);
+     }
 #endif
 #if 0
    case chvar_tag:
      e = son(e);		/* fall through, look at arg */
 #endif
       case mult_tag:
 	if (last(arg2) && name(arg2) == val_tag)
+	{
 	  return 0;
+	}
 	return 1;
       }
     case div0_tag:
     case rem0_tag:
     case div1_tag:
     case div2_tag:
     case mod_tag:
     case rem2_tag:
     case offset_div_tag:
     case offset_div_by_int_tag:
+      {
 	/*remneeds, divneeds - simple cases don't need a call */
 	exp arg2 = bro(son(e));
 	if (last(arg2) && name(arg2) == val_tag)
 /*
  * Needs estimation
  */
 needs multneeds
-    PROTO_N ( ( e, at ) )
-    PROTO_T ( exp * e X exp ** at )
+(exp * e, exp ** at)
+{
-  needs n ;
+  needs n;
   exp arg1 = son(*(e));
   exp arg2 = bro(arg1);
   n = likeplus(e, at);	/* has had comm_ass() treatment */
   /* remember that mult may have more than two args after optimisation */
 #endif
   return n;
+}
 needs divneeds
-    PROTO_N ( ( e, at ) )
-    PROTO_T ( exp * e X exp ** at )
+(exp * e, exp ** at)
+{
-  needs n ;
+  needs n;
   exp lhs = son(*(e));
   exp rhs = bro(lhs);
   n = likediv(e, at);
   assert(last(rhs));
   return n;
+}
 needs remneeds
-    PROTO_N ( ( e, at ) )
-    PROTO_T ( exp * e X exp ** at )
+(exp * e, exp ** at)
+{
-  needs n ;
+  needs n;
   exp lhs = son(*(e));
   exp rhs = bro(lhs);
   n = likediv(e, at);
   assert(last(rhs));

Subversion Repositories tendra.SVN

(root)/trunk/src/installers/hppa/common/muldvrem.c – Rev 2 → 7