WebSVN – tendra.SVN – Diff – /trunk/src/installers/680x0/common/ops_logic.c

+/*
+ * Copyright (c) 2002-2006 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) 1996
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
     AND/OR/XOR BY A CONSTANT
     The value a of shape sha and size sz has the logical operator indicated
     by logop applied to it and the constant c.  The result is stored in
     dest.  instr is one of m_andl, m_orl, eorl.
 */
-static void andetc_const
+static void
-    PROTO_N ( ( instr, sha, sz, c, a, dest, logop ) )
-    PROTO_T ( int instr X shape sha X long sz X long c X where a X where dest X int logop )
+andetc_const(int instr, shape sha, long sz, long c, where a, where dest,
+	     int logop)
 {
-    long whd ;
+	long whd;
-    /* First check that a is not a constant */
+	/* First check that a is not a constant */
-    if ( whereis ( a ) == Value ) {
+	if (whereis(a) == Value) {
-	long ca = nw ( a ) ;
+		long ca = nw(a);
-	switch ( logop ) {
+		switch (logop) {
-	    case AND : ca &= c ; break ;
+		case AND:
+			ca &= c;
+			break;
+		case OR:
-	    case OR  : ca |= c ; break ;
+			ca |= c;
+			break;
-	    case XOR : ca ^= c ; break ;
+		case XOR:
+			ca ^= c;
+			break;
-	}
+		}
-	move ( sha, mnw ( ca ), dest ) ;
+		move(sha, mnw(ca), dest);
-	return ;
+		return;
-    }
+	}
-    /* Now look for some special values of c */
+	/* Now look for some special values of c */
-    switch ( logop ) {
+	switch (logop) {
-	case AND : {
+	case AND: {
-	    long cc ;
+		long cc;
-	    if ( c == 0 ) {
+		if (c == 0) {
-		move ( sha, zero, dest ) ;
+			move(sha, zero, dest);
-		return ;
+			return;
-	    }
+		}
-	    cc = ~c ;
+		cc = ~c;
-	    if ( sz == 32 ) {
+		if (sz == 32) {
-		if ( cc == 0 ) {
+			if (cc == 0) {
-		    change_var ( sha, a, dest ) ;
+				change_var(sha, a, dest);
-		    return ;
+				return;
-		}
+			}
-		if ( is_pow2 ( cc ) ) {
+			if (is_pow2(cc)) {
-		    long p = log2 ( cc ) ;
+				long p = log2(cc);
-		    if ( whereis ( dest ) == Dreg ) {
+				if (whereis(dest) == Dreg) {
-			change_var ( sha, a, dest ) ;
+					change_var(sha, a, dest);
-			ins2n ( m_bclr, p, sz, dest, 1 ) ;
+					ins2n(m_bclr, p, sz, dest, 1);
-			have_cond = 0 ;
+					have_cond = 0;
-			return ;
+					return;
-		    }
+				}
-		}
+			}
-	    }
+		}
-	    break ;
+		break;
 	}
-	case OR : {
+	case OR:
-	    if ( c == 0 ) {
+		if (c == 0) {
-		change_var ( sha, a, dest ) ;
+			change_var(sha, a, dest);
-		return ;
+			return;
-	    }
+		}
-	    if ( is_pow2 ( c ) ) {
+		if (is_pow2(c)) {
-		long p = log2 ( c ) ;
+			long p = log2(c);
-		if ( whereis ( dest ) == Dreg ) {
+			if (whereis(dest) == Dreg) {
-		    change_var ( sha, a, dest ) ;
+				change_var(sha, a, dest);
-		    ins2n ( m_bset, p, sz, dest, 1 ) ;
+				ins2n(m_bset, p, sz, dest, 1);
-		    have_cond = 0 ;
+				have_cond = 0;
-		    return ;
+				return;
-		}
+			}
-	    }
+		}
-	    break ;
+		break;
-	}
-	case XOR : {
+	case XOR:
-	    if ( c == 0 ) {
+		if (c == 0) {
-		change_var ( sha, a, dest ) ;
+			change_var(sha, a, dest);
-		return ;
+			return;
-	    }
+		}
-	    break ;
+		break;
 	}
-    }
-    whd = whereis ( dest ) ;
+	whd = whereis(dest);
-    if ( whd != Areg && eq_where ( a, dest ) ) {
+	if (whd != Areg && eq_where(a, dest)) {
-	ins2h ( instr, c, sz, dest, 1 ) ;
+		ins2h(instr, c, sz, dest, 1);
-	set_cond ( dest, sz ) ;
+		set_cond(dest, sz);
-	return ;
+		return;
-    }
+	}
-    if ( whd == Dreg ) {
+	if (whd == Dreg) {
-	change_var ( sha, a, dest ) ;
+		change_var(sha, a, dest);
-	ins2h ( instr, c, sz, dest, 1 ) ;
+		ins2h(instr, c, sz, dest, 1);
-	set_cond ( dest, sz ) ;
+		set_cond(dest, sz);
-	return ;
+		return;
-    }
+	}
-    if ( whereis ( a ) == Dreg && last_use ( a ) ) {
+	if (whereis(a) == Dreg && last_use(a)) {
-	ins2h ( instr, c, sz, a, 1 ) ;
+		ins2h(instr, c, sz, a, 1);
-	change_var ( sha, a, dest ) ;
+		change_var(sha, a, dest);
-	set_cond ( dest, sz ) ;
+		set_cond(dest, sz);
-	return ;
+		return;
-    }
+	}
-    change_var ( sha, a, D0 ) ;
+	change_var(sha, a, D0);
-    ins2h ( instr, c, sz, D0, 1 ) ;
+	ins2h(instr, c, sz, D0, 1);
-    move ( sha, D0, dest ) ;
+	move(sha, D0, dest);
-    set_cond ( dest, sz ) ;
+	set_cond(dest, sz);
-    return ;
+	return;
 }
 /*
     AUXILLARY ROUTINE FOR AND/OR/XOR
     The values a1 and a2 of shape sha have the logical operation indicated
     by logop applied to them and the result is stored in dest.  ( opb,
     opw, opl ) is an ordered triple giving the byte, word and long forms of
     the appropriate machine instruction.
 */
-static void andetc
+static void
-    PROTO_N ( ( opb, opw, opl, sha, a1, a2, dest, logop ) )
-    PROTO_T ( int opb X int opw X int opl X shape sha X where a1 X where a2 X where dest X int logop )
+andetc(int opb, int opw, int opl, shape sha, where a1, where a2, where dest,
+       int logop)
+{
-    int instr ;
+	int instr;
-    long wha, whb, whd ;
+	long wha, whb, whd;
-    long sz = shape_size ( sha ) ;
+	long sz = shape_size(sha);
-    if ( eq_where ( a1, a2 ) ) {
-	switch ( logop ) {
-	    case AND : move ( sha, a1, dest ) ; return ;
-	    case OR  : move ( sha, a1, dest ) ; return ;
-	    case XOR : move ( sha, zero, dest ) ; return ;
-	}
-    }
-    instr = ins ( sz, opb, opw, opl ) ;
-    wha = whereis ( a1 ) ;
-    whb = whereis ( a2 ) ;
-    if ( wha == Freg ) {
-	move ( sha, a1, D0 ) ;
-	andetc ( opb, opw, opl, sha, D0, a2, dest, logop ) ;
-	return ;
-    }
-    if ( whb == Freg ) {
-	move ( sha, a2, D0 ) ;
-	andetc ( opb, opw, opl, sha, a1, D0, dest, logop ) ;
-	return ;
-    }
-    if ( wha == Value ) {
-	long c = nw ( a1 ) ;
-	andetc_const ( instr, sha, sz, c, a2, dest, logop ) ;
-	return ;
-    }
+	if (eq_where(a1, a2)) {
+		switch (logop) {
+		case AND:
+			move(sha, a1, dest);
+			return;
+		case OR:
+			move(sha, a1, dest);
+			return;
+		case XOR:
+			move(sha, zero, dest);
+			return;
+		}
+	}
+	instr = ins(sz, opb, opw, opl);
+	wha = whereis(a1);
+	whb = whereis(a2);
+	if (wha == Freg) {
+		move(sha, a1, D0);
+		andetc(opb, opw, opl, sha, D0, a2, dest, logop);
+		return;
+	}
+	if (whb == Freg) {
+		move(sha, a2, D0);
+		andetc(opb, opw, opl, sha, a1, D0, dest, logop);
+		return;
+	}
+	if (wha == Value) {
+		long c = nw(a1);
+		andetc_const(instr, sha, sz, c, a2, dest, logop);
+		return;
+	}
-    if ( whb == Value ) {
+	if (whb == Value) {
-	long c = nw ( a2 ) ;
+		long c = nw(a2);
-	andetc_const ( instr, sha, sz, c, a1, dest, logop ) ;
+		andetc_const(instr, sha, sz, c, a1, dest, logop);
-	return ;
+		return;
-    }
+	}
-    whd = whereis ( dest ) ;
+	whd = whereis(dest);
-    if ( eq_where ( a1, dest ) && whd != Areg ) {
+	if (eq_where(a1, dest) && whd != Areg) {
-	if ( whb == Dreg ) {
+		if (whb == Dreg) {
-	    ins2 ( instr, sz, sz, a2, dest, 1 ) ;
+			ins2(instr, sz, sz, a2, dest, 1);
+			return;
+		}
+		if (whd == Dreg) {
+			if (logop == XOR || whb == Areg) {
+				if (eq_where(dest, D0)) {
+					regsinproc |= regmsk(REG_D1);
+					move(sha, a2, D1);
+					ins2(instr, sz, sz, D1, dest, 1);
+					set_cond(dest, sz);
+					return;
+				} else {
+					move(sha, a2, D0);
+					ins2(instr, sz, sz, D0, dest, 1);
+					set_cond(dest, sz);
-	    return ;
+					return;
+				}
+			} else {
+				ins2(instr, sz, sz, a2, dest, 1);
+				set_cond(dest, sz);
+				return;
+			}
+		} else {
+			move(sha, a2, D0);
+			ins2(instr, sz, sz, D0, dest, 1);
+			set_cond(dest, sz);
+			return;
+		}
+	}
-	if ( whd == Dreg ) {
-	    if ( logop == XOR || whb == Areg ) {
-		if ( eq_where ( dest, D0 ) ) {
+	if (eq_where(a2, dest) && whd != Areg) {
-		    regsinproc |= regmsk ( REG_D1 ) ;
-		    move ( sha, a2, D1 ) ;
+		if (wha == Dreg) {
-		    ins2 ( instr, sz, sz, D1, dest, 1 ) ;
+			ins2(instr, sz, sz, a1, dest, 1);
-		    set_cond ( dest, sz ) ;
-		    return ;
-		} else {
-		    move ( sha, a2, D0 ) ;
-		    ins2 ( instr, sz, sz, D0, dest, 1 ) ;
-		    set_cond ( dest, sz ) ;
+			set_cond(dest, sz);
-		    return ;
+			return;
+		}
-	    } else {
+		if (whd == Dreg) {
+			if (logop == XOR || wha == Areg || wha == Freg) {
+				if (eq_where(dest, D0)) {
+					regsinproc |= regmsk(REG_D1);
+					move(sha, a1, D1);
-		ins2 ( instr, sz, sz, a2, dest, 1 ) ;
+					ins2(instr, sz, sz, D1, dest, 1);
+				} else {
-		set_cond ( dest, sz ) ;
+					move(sha, a1, D0);
+					ins2(instr, sz, sz, D0, dest, 1);
+				}
-		return ;
+			} else {
+				ins2(instr, sz, sz, a1, dest, 1);
-	    }
+			}
-	} else {
+		} else {
-	    move ( sha, a2, D0 ) ;
+			move(sha, a1, D0);
-	    ins2 ( instr, sz, sz, D0, dest, 1 ) ;
+			ins2(instr, sz, sz, D0, dest, 1);
+		}
-	    set_cond ( dest, sz ) ;
+		set_cond(dest, sz);
-	    return ;
+		return;
 	}
-    }
-    if ( eq_where ( a2, dest ) && whd != Areg ) {
-	if ( wha == Dreg ) {
+	if (whd == Dreg) {
-	    ins2 ( instr, sz, sz, a1, dest, 1 ) ;
+		if (!interfere(a2, dest)) {
-	    set_cond ( dest, sz ) ;
+			move(sha, a1, dest);
+			andetc(opb, opw, opl, sha, a2, dest, dest, logop);
-	    return ;
+			return;
-	}
+		}
-	if ( whd == Dreg ) {
-	    if ( logop == XOR || wha == Areg || wha == Freg ) {
-		if ( eq_where ( dest, D0 ) ) {
+		if (!interfere(a1, dest)) {
-		    regsinproc |= regmsk ( REG_D1 ) ;
-		    move ( sha, a1, D1 ) ;
+			move(sha, a2, dest);
-		    ins2 ( instr, sz, sz, D1, dest, 1 ) ;
+			andetc(opb, opw, opl, sha, a1, dest, dest, logop);
-		} else {
+			return;
-		    move ( sha, a1, D0 ) ;
-		    ins2 ( instr, sz, sz, D0, dest, 1 ) ;
+		}
-	    } else {
-		ins2 ( instr, sz, sz, a1, dest, 1 ) ;
-	    }
-	} else {
-	    move ( sha, a1, D0 ) ;
-	    ins2 ( instr, sz, sz, D0, dest, 1 ) ;
-	}
-	set_cond ( dest, sz ) ;
-	return ;
-    }
-    if ( whd == Dreg ) {
-	if ( !interfere ( a2, dest ) ) {
-	    move ( sha, a1, dest ) ;
-	    andetc ( opb, opw, opl, sha, a2, dest, dest, logop ) ;
-	    return ;
-	}
-	if ( !interfere ( a1, dest ) ) {
-	    move ( sha, a2, dest ) ;
-	    andetc ( opb, opw, opl, sha, a1, dest, dest, logop ) ;
-	    return ;
+	}
-    }
-    move ( sha, a1, D0 ) ;
+	move(sha, a1, D0);
-    andetc ( opb, opw, opl, sha, a2, D0, D0, logop ) ;
+	andetc(opb, opw, opl, sha, a2, D0, D0, logop);
-    move ( sha, D0, dest ) ;
+	move(sha, D0, dest);
-    return ;
+	return;
+}
 /*
     AND INSTRUCTION
     The values a1 and a2 of shape sha are anded and the result is stored
     in dested.
 */
-void and
+void
-    PROTO_N ( ( sha, a1, a2, dest ) )
-    PROTO_T ( shape sha X where a1 X where a2 X where dest )
+and(shape sha, where a1, where a2, where dest)
 {
-    andetc ( ml_and, sha, a1, a2, dest, AND ) ;
+	andetc(ml_and, sha, a1, a2, dest, AND);
-    return ;
+	return;
 }
 /*
     OR INSTRUCTION
     The values a1 and a2 of shape sha are ored and the result is stored
     in dested.
 */
-void or
+void
-    PROTO_N ( ( sha, a1, a2, dest ) )
-    PROTO_T ( shape sha X where a1 X where a2 X where dest )
+or(shape sha, where a1, where a2, where dest)
 {
-    andetc ( ml_or, sha, a1, a2, dest, OR ) ;
+	andetc(ml_or, sha, a1, a2, dest, OR);
-    return ;
+	return;
 }
 /*
     XOR INSTRUCTION
     The values a1 and a2 of shape sha are xored and the result is stored
     in dested.
 */
-void xor
+void
-    PROTO_N ( ( sha, a1, a2, dest ) )
-    PROTO_T ( shape sha X where a1 X where a2 X where dest )
+xor(shape sha, where a1, where a2, where dest)
 {
-    andetc ( ml_eor, sha, a1, a2, dest, XOR ) ;
+	andetc(ml_eor, sha, a1, a2, dest, XOR);
-    return ;
+	return;
 }
 /*
     LOGICAL NEGATION INSTRUCTION
     The value a of shape sha is logically negated and the result is stored
     in dest.
 */
-void not
+void
-    PROTO_N ( ( sha, a, dest ) )
-    PROTO_T ( shape sha X where a X where dest )
+not(shape sha, where a, where dest)
+{
-    int instr ;
+	int instr;
-    long sz = shape_size ( sha ) ;
+	long sz = shape_size(sha);
-    long wha = whereis ( a ) ;
+	long wha = whereis(a);
-    long whd = whereis ( dest ) ;
+	long whd = whereis(dest);
-    if ( wha == Value ) {
-	long c = nw ( a ) ;
-	move ( sha, mnw ( ~c ), dest ) ;
-	return ;
-    }
-    if ( eq_where ( a, dest ) && whd != Areg ) {
-	instr = ins ( sz, ml_not ) ;
-	ins1 ( instr, sz, dest, 1 ) ;
-	set_cond ( dest, sz ) ;
-	return ;
-    }
-    if ( whd == Dreg ) {
-	move ( sha, a, dest ) ;
-	not ( sha, dest, dest ) ;
-	return ;
-    }
-    if ( wha == Dreg && last_use ( a ) ) {
-	not ( sha, a, a ) ;
-	move ( sha, a, dest ) ;
-	return ;
-    }
+	if (wha == Value) {
+		long c = nw(a);
+		move(sha, mnw(~c), dest);
+		return;
+	}
+	if (eq_where(a, dest) && whd != Areg) {
+		instr = ins(sz, ml_not);
+		ins1(instr, sz, dest, 1);
+		set_cond(dest, sz);
+		return;
+	}
+	if (whd == Dreg) {
+		move(sha, a, dest);
+		not(sha, dest, dest);
+		return;
+	}
+	if (wha == Dreg && last_use(a)) {
+		not(sha, a, a);
+		move(sha, a, dest);
+		return;
+	}
-    move ( sha, a, D0 ) ;
+	move(sha, a, D0);
-    not ( sha, D0, D0 ) ;
+	not(sha, D0, D0);
-    move ( sha, D0, dest ) ;
+	move(sha, D0, dest);
-    return ;
+	return;
+}
 /*
     LOW LEVEL SHIFT
     This routine outputs a simple shift instruction, taking overflow
     into account if necessary (not right yet).
 */
-static void shift_it
+static void
-    PROTO_N ( ( sha, shb, instr, by, to ) )
-    PROTO_T ( shape sha X shape shb X int instr X where by X where to )
+shift_it(shape sha, shape shb, int instr, where by, where to)
 {
-    long sz = shape_size ( sha ) ;
+	long sz = shape_size(sha);
-    ins2 ( instr, L8, sz, by, to, 1 ) ;
+	ins2(instr, L8, sz, by, to, 1);
-    have_cond = 0 ;
+	have_cond = 0;
-    test_overflow( ON_OVERFLOW ) ;
+	test_overflow(ON_OVERFLOW);
-    return ;
+	return;
 }
 /*
     AUXILIARY SHIFT ROUTINE
     The value from of shape sha is shifted, either left if sw is 0, or
     right otherwise, by the value by.  The result is stored in to.
     The dont_use_D1 flag indicates that register D1 should not be used.
     It is always false for simple shifts, but may be true for certain
     multiplications which are done by shifts.
 */
-void shift_aux
+void
-    PROTO_N ( ( sha, by, from, to, sw, dont_use_D1 ) )
-    PROTO_T ( shape sha X where by X where from X where to X int sw X int dont_use_D1 )
+shift_aux(shape sha, where by, where from, where to, int sw, int dont_use_D1)
+{
+}
 /*
+    MAIN LEFT SHIFT ROUTINE
+    The value from of shape sha is shifted left by the value by.  The
+    result is stored in to.
+*/
+void
+shift(shape sha, where by, where from, where to)
+{
+	shift_aux(sha, by, from, to, 0, 0);
+	return;
+}
+/*
     MAIN RIGHT SHIFT ROUTINE
     The value from of shape sha is shifted right by the value by.  The
     result is stored in to.
 */
-void rshift
+void
-    PROTO_N ( ( sha, by, from, to ) )
-    PROTO_T ( shape sha X where by X where from X where to )
+rshift(shape sha, where by, where from, where to)
 {
-    shift_aux ( sha, by, from, to, 1, 0 ) ;
+	shift_aux(sha, by, from, to, 1, 0);
-    return ;
+	return;
+}
 /*
     ADJUST AN EXPRESSION READY FOR A BITFIELD OPERATION
     The value in the no field of e is rounded down to a multiple of 32.
     The remainder is the bitfield offset and is returned.
 */
-static long adjust_bitf
+static long
-    PROTO_N ( ( e ) )
-    PROTO_T ( exp e )
+adjust_bitf(exp e)
 {
-    long boff = no ( e ) % 32 ;
+	long boff = no(e)% 32;
-    no ( e ) -= boff ;
+	no(e) -= boff;
-    return ( boff ) ;
+	return (boff);
+}
+/*
+    FIND POSITION OF A CONTENTS BITFIELD
+*/
+static long
+contents_bitf(exp e)
+{
+	char n = name(e);
+	if (n == name_tag || n == reff_tag) {
+		return (adjust_bitf(e));
+	}
+	if (n == ident_tag) {
+		exp s = son(e);
+		exp b = bro(s);
+		if (name(b) == reff_tag) {
+			return (adjust_bitf(b));
+		}
+		if (name(b) == ident_tag) {
+			return (contents_bitf(b));
+		}
+		if (name(b) == name_tag && son(b) == e &&
+		    name(s) == name_tag) {
+			return (contents_bitf(son(s)));
+		}
+		if (name(s) == name_tag) {
+			return (adjust_bitf(s));
+		}
+	}
+	error("Illegal bitfield operation");
+	return (0);
 }
 /*
-    FIND POSITION OF A CONTENTS BITFIELD
+    FIND POSITION OF A BITFIELD OPERATION
 */
-static long contents_bitf
+static long
-    PROTO_N ( ( e ) )
-    PROTO_T ( exp e )
+bitf_posn(exp e)
+{
-    char n = name ( e ) ;
+	char n = name(e);
-    if ( n == name_tag || n == reff_tag ) return ( adjust_bitf ( e ) ) ;
-    if ( n == ident_tag ) {
+	if (n == name_tag) {
-	exp s = son ( e ) ;
+		return (adjust_bitf(e));
-	exp b = bro ( s ) ;
+	}
-	if ( name ( b ) == reff_tag ) return ( adjust_bitf ( b ) ) ;
+	if (n == cont_tag || n == ass_tag) {
-	if ( name ( b ) == ident_tag ) return ( contents_bitf ( b ) ) ;
-	if ( name ( b ) == name_tag && son ( b ) == e &&
+		return (bitf_posn(son(e)));
+	}
-	     name ( s ) == name_tag ) {
+	if (n == ident_tag) {
-	    return ( contents_bitf ( son ( s ) ) ) ;
+		return (0);
+	}
-	if ( name ( s ) == name_tag ) return ( adjust_bitf ( s ) ) ;
-    }
-    error ( "Illegal bitfield operation" ) ;
+	error("Illegal bitfield operation");
-    return ( 0 ) ;
-}
-/*
-    FIND POSITION OF A BITFIELD OPERATION
-*/
-static long bitf_posn
-    PROTO_N ( ( e ) )
-    PROTO_T ( exp e )
-{
-    char n = name ( e ) ;
-    if ( n == name_tag ) return ( adjust_bitf ( e ) ) ;
-    if ( n == cont_tag || n == ass_tag ) {
-	return ( bitf_posn ( son ( e ) ) ) ;
-    }
-    if ( n == ident_tag ) return ( 0 ) ;
-    error ( "Illegal bitfield operation" ) ;
-    return ( 0 ) ;
+	return (0);
+}
 /*
     EXTRACT A BITFIELD
     The bitfield e of shape sha is extracted into dest.  The current state
     of the stack is also given.
 */
-void bitf_to_int
+void
-    PROTO_N ( ( e, sha, dest, stack ) )
-    PROTO_T ( exp e X shape sha X where dest X ash stack )
+bitf_to_int(exp e, shape sha, where dest, ash stack)
 {
-    where bf, d ;
+	where bf, d;
-    exp t = dest.wh_exp ;
+	exp t = dest.wh_exp;
-    shape dsha = sh ( t ) ;
+	shape dsha = sh(t);
-    int extend = ( is_signed ( sha ) ? 1 : 0 ) ;
+	int extend = (is_signed(sha)? 1 : 0);
-    int instr = ( extend ? m_bfexts : m_bfextu ) ;
+	int instr = (extend ? m_bfexts : m_bfextu);
-    long off, sz, bstart ;
+	long off, sz, bstart;
-    bitpattern pmask ;
+	bitpattern pmask;
-    long nbits = shape_size ( sha ) ;
+	long nbits = shape_size(sha);
-    long boff = bitf_posn ( e ) ;
+	long boff = bitf_posn(e);
-    off = 8 * ( boff / 8 ) ;
+	off = 8 *(boff / 8);
-    sz = 8 * ( ( boff + nbits - 1 ) / 8 ) + 8 - off ;
+	sz = 8 *((boff + nbits - 1) / 8) + 8 - off;
-    if ( sz == 24 ) { sz = 32 ; off -= 8 ; }
+	if (sz == 24) {
+		sz = 32;
+		off -= 8;
+	}
-    bstart = boff - off ;
+	bstart = boff - off;
-    pmask = ( ( hi_bits [ nbits ] ) >> bstart ) >> ( 32 - sz ) ;
+	pmask = ((hi_bits[nbits]) >> bstart) >> (32 - sz);
-    switch ( name ( t ) ) {
+	switch (name(t)) {
+	case ident_tag:
-	case ident_tag : dsha = sh ( son ( t ) ) ; break ;
+		dsha = sh(son(t));
+		break;
+	case ass_tag:
-	case ass_tag : dsha = sh ( bro ( son ( t ) ) ) ; break ;
+		dsha = sh(bro(son(t)));
+		break;
-    }
+	}
+	if (name(dsha) == bitfhd) {
-    if ( name ( dsha ) == bitfhd ) dsha = ( extend ? slongsh : ulongsh ) ;
+		dsha = (extend ? slongsh : ulongsh);
+	}
+	if (name(dsha) == tophd) {
-    if ( name ( dsha ) == tophd ) warning ( "Top in bitfield assignment" ) ;
+		warning("Top in bitfield assignment");
+	}
-    bf = mw ( e, off ) ;
+	bf = mw(e, off);
-    if ( bstart == 0 && nbits == sz ) {
+	if (bstart == 0 && nbits == sz) {
-	shape bsha ;
+		shape bsha;
-	switch ( sz ) {
+		switch (sz) {
+		case 8:
-	    case 8 : bsha = scharsh ; break ;
+			bsha = scharsh;
+			break;
+		case 16:
-	    case 16 : bsha = swordsh ; break ;
+			bsha = swordsh;
+			break;
+		case 32:
-	    case 32 : bsha = slongsh ; break ;
+			bsha = slongsh;
+			break;
-	}
+		}
-	change_var_sh ( dsha, bsha, bf, dest ) ;
+		change_var_sh(dsha, bsha, bf, dest);
-	return ;
+		return;
-    }
+	}
-    if ( whereis ( bf ) == Dreg ) {
+	if (whereis(bf) == Dreg) {
-	bitpattern m = ( lo_bits [ nbits ] <<  boff ) ;
+		bitpattern m = (lo_bits[nbits] <<  boff);
-	d = ( whereis ( dest ) == Dreg ? dest : D0 ) ;
+		d = (whereis(dest) == Dreg ? dest : D0);
-	and ( slongsh, bf, mnw ( m ), d ) ;
+		and(slongsh, bf, mnw(m), d);
-	if ( extend ) {
+		if (extend) {
-	    long r = 32 - nbits - boff ;
+			long r = 32 - nbits - boff;
-	    if ( r ) {
+			if (r) {
-		if ( r <= 8 ) {
+				if (r <= 8) {
-		    ins2n ( m_lsll, r, L32, d, 1 ) ;
+					ins2n(m_lsll, r, L32, d, 1);
-		    ins2n ( m_asrl, r, L32, d, 1 ) ;
+					ins2n(m_asrl, r, L32, d, 1);
-		} else {
+				} else {
-		    regsinproc |= regmsk ( REG_D1 ) ;
+					regsinproc |= regmsk(REG_D1);
-		    ins2n ( m_moveq, r, L32, D1, 1 ) ;
+					ins2n(m_moveq, r, L32, D1, 1);
-		    ins2 ( m_lsll, L32, L32, D1, d, 1 ) ;
+					ins2(m_lsll, L32, L32, D1, d, 1);
-		    ins2 ( m_asrl, L32, L32, D1, d, 1 ) ;
+					ins2(m_asrl, L32, L32, D1, d, 1);
-		}
+				}
-	    }
+			}
-	}
+		}
-	have_cond = 0 ;
+		have_cond = 0;
-	change_var_sh ( dsha, slongsh, d, dest ) ;
+		change_var_sh(dsha, slongsh, d, dest);
-	return ;
+		return;
-    } else {
+	} else {
-	mach_op *op1, *op2 ;
+		mach_op *op1, *op2;
-	d = ( whereis ( dest ) == Dreg ? dest : D0 ) ;
+		d = (whereis(dest) == Dreg ? dest : D0);
-	op1 = operand ( L32, bf ) ;
+		op1 = operand(L32, bf);
-	op1 = make_bitfield_op ( op1, ( int ) bstart, ( int ) nbits ) ;
+		op1 = make_bitfield_op(op1,(int)bstart,(int)nbits);
-	op2 = operand ( L32, d ) ;
+		op2 = operand(L32, d);
-	make_instr ( instr, op1, op2, regs_changed ( op2, 1 ) ) ;
+		make_instr(instr, op1, op2, regs_changed(op2, 1));
-	have_cond = 0 ;
+		have_cond = 0;
-	change_var_sh ( dsha, slongsh, d, dest ) ;
+		change_var_sh(dsha, slongsh, d, dest);
-	return ;
+		return;
-    }
+	}
 }
 /*
     INSERT A BITFIELD
     The value e is inserted into the bitfield d.  The state of the stack
     is also given.
 */
-void int_to_bitf
+void
-    PROTO_N ( ( e, d, stack ) )
-    PROTO_T ( exp e X exp d X ash stack )
+int_to_bitf(exp e, exp d, ash stack)
 {
-    shape sha ;
+	shape sha;
-    where dest, f ;
+	where dest, f;
-    long off, sz, bstart, bend ;
+	long off, sz, bstart, bend;
-    bitpattern pmask, nmask, v ;
+	bitpattern pmask, nmask, v;
-    long nbits = shape_size ( sh ( e ) ) ;
+	long nbits = shape_size(sh(e));
-    long boff = bitf_posn ( d ) ;
+	long boff = bitf_posn(d);
-    off = 8 * ( boff / 8 ) ;
+	off = 8 *(boff / 8);
-    sz = 8 * ( ( boff + nbits - 1 ) / 8 ) + 8 - off ;
+	sz = 8 *((boff + nbits - 1) / 8) + 8 - off;
-    if ( sz == 24 ) { sz = 32 ; off -= 8 ; }
+	if (sz == 24) {
+		sz = 32;
+		off -= 8;
+	}
-    bstart = boff - off ;
+	bstart = boff - off;
-    bend = sz - nbits - bstart ;
+	bend = sz - nbits - bstart;
-    pmask = ( ( hi_bits [ nbits ] ) >> bstart ) >> ( 32 - sz ) ;
+	pmask = ((hi_bits[nbits]) >> bstart) >> (32 - sz);
-    nmask = ~pmask ;
+	nmask = ~pmask;
-    switch ( sz ) {
+	switch (sz) {
+	case 8:
+		nmask &= 0xff;
-	case 8 : nmask &= 0xff ; sha = scharsh ; break ;
+		sha = scharsh;
+		break;
+	case 16:
-	case 16 : nmask &= 0xffff ; sha = swordsh ; break ;
+		nmask &= 0xffff;
+		sha = swordsh;
+		break;
+	default:
-	default : sha = slongsh ; break ;
+		sha = slongsh;
+		break;
-    }
+	}
-    if ( name ( e ) == int_to_bitf_tag ) {
+	if (name(e) == int_to_bitf_tag) {
-	exp s = son ( e ) ;
+		exp s = son(e);
-	if ( is_o ( name ( s ) ) ) {
+		if (is_o(name(s))) {
-	    e = s ;
+			e = s;
-	} else {
+		} else {
-	    regsinproc |= regmsk ( REG_D1 ) ;
+			regsinproc |= regmsk(REG_D1);
-	    coder ( D1, stack, s ) ;
+			coder(D1, stack, s);
-	    if ( shape_size ( sh ( s ) ) < 32 ) warning ( "Think again!" ) ;
+			if (shape_size(sh(s)) < 32) {
+				warning("Think again!");
+			}
-	    e = D1.wh_exp ;
+			e = D1.wh_exp;
-	}
+		}
-    }
+	}
-    dest = mw ( d, off ) ;
+	dest = mw(d, off);
-    if ( bstart == 0 && nbits == sz ) {
+	if (bstart == 0 && nbits == sz) {
-	change_var_sh ( sha, sh ( e ), zw ( e ), dest ) ;
+		change_var_sh(sha, sh(e), zw(e), dest);
-	return ;
+		return;
-    }
+	}
-    if ( ( bstart + nbits > 32 ) || ( name ( e ) != val_tag ) ) {
+	if ((bstart + nbits > 32) || (name(e)!= val_tag)) {
-	where dd ;
+		where dd;
-	bitpattern ch ;
+		bitpattern ch;
-	mach_op *op1, *op2 ;
+		mach_op *op1, *op2;
-	dd = zw ( e ) ;
+		dd = zw(e);
-	if ( whereis ( dd ) != Dreg || shape_size ( sh ( e ) ) != 32 ) {
+		if (whereis(dd)!= Dreg || shape_size(sh(e))!= 32) {
-	    change_var_sh ( slongsh, sh ( e ), dd, D0 ) ;
+			change_var_sh(slongsh, sh(e), dd, D0);
-	    dd = D0 ;
+			dd = D0;
-	}
+		}
-	op1 = operand ( L32, dd ) ;
+		op1 = operand(L32, dd);
-	op2 = operand ( L32, dest ) ;
+		op2 = operand(L32, dest);
-	ch = regs_changed ( op2, 1 ) ;
+		ch = regs_changed(op2, 1);
-	op2 = make_bitfield_op ( op2, ( int ) bstart, ( int ) nbits ) ;
+		op2 = make_bitfield_op(op2,(int)bstart,(int)nbits);
-	make_instr ( m_bfins, op1, op2, ch ) ;
+		make_instr(m_bfins, op1, op2, ch);
-	have_cond = 0 ;
+		have_cond = 0;
-	return ;
+		return;
-    }
+	}
-    v = ( bitpattern ) no ( e ) ;
+	v = (bitpattern)no(e);
-    v = ( ( v << bend ) & pmask ) ;
+	v = ((v << bend) & pmask);
-    if ( v == 0 ) {
+	if (v == 0) {
-	and ( sha, mnw ( nmask ), dest, dest ) ;
+		and(sha, mnw(nmask), dest, dest);
-	return ;
+		return;
-    }
+	}
-    if ( v == pmask ) {
+	if (v == pmask) {
-	or ( sha, mnw ( pmask ), dest, dest ) ;
+		or(sha, mnw(pmask), dest, dest);
-	return ;
+		return;
-    }
+	}
-    f = ( ( whereis ( dest ) == Dreg ) ? dest : D0 ) ;
+	f = ((whereis(dest) == Dreg)? dest : D0);
-    and ( sha, mnw ( nmask ), dest, f ) ;
+	and(sha, mnw(nmask), dest, f);
-    or ( sha, mnw ( v ), f, dest ) ;
+	or(sha, mnw(v), f, dest);
-    return ;
+	return;
 }
 /*
     TEST A NUMBER OF BITS
     the value a2 are set.  If a2 is a constant power of 2 then a bit
     test operation is used.  Otherwise a1 is anded with a2 and the
     result is stored in an unwanted D-register.
 */
-void bit_test
+void
-    PROTO_N ( ( sha, a1, a2 ) )
-    PROTO_T ( shape sha X where a1 X where a2 )
+bit_test(shape sha, where a1, where a2)
+{
-    long sz = shape_size ( sha ) ;
+	long sz = shape_size(sha);
-    long wh1 = whereis ( a1 ) ;
+	long wh1 = whereis(a1);
-    long wh2 = whereis ( a2 ) ;
+	long wh2 = whereis(a2);
-    if ( wh2 == Value ) {
+	if (wh2 == Value) {
-	if ( wh1 == External || wh1 == Parameter || wh1 == RegInd ) {
+		if (wh1 == External || wh1 == Parameter || wh1 == RegInd) {
-	    long v = nw ( a2 ) ;
+			long v = nw(a2);
-	    if ( is_pow2 ( v ) ) {
+			if (is_pow2(v)) {
-		where w ;
+				where w;
-		long n = log2 ( v ) ;
+				long n = log2(v);
-		long off = sz - 8 * ( 1 + ( n / 8 ) ) ;
+				long off = sz - 8 *(1 + (n / 8));
-		w = mw ( a1.wh_exp, a1.wh_off + off ) ;
+				w = mw(a1.wh_exp, a1.wh_off + off);
-		ins2n ( m_btstb, n % 8, 8, w, 1 ) ;
+				ins2n(m_btstb, n % 8, 8, w, 1);
+				have_cond = 0;
+				return;
+			}
+		}
+		if (wh1 == Dreg) {
+			long v = nw(a2);
+			if (last_use(a1)) {
+				and(sha, a2, a1, a1);
+				return;
+			}
+			if (is_pow2(v) && sz == 32) {
+				long n = log2(v);
+				ins2n(m_btstl, n, sz, a1, 1);
-		have_cond = 0 ;
+				have_cond = 0;
-		return ;
+				return;
-	    }
+			}
+		}
+	}
+	if (wh1 == Dreg && last_use(a1)) {
+		and(sha, a2, a1, a1);
+		return;
+	}
-	if ( wh1 == Dreg ) {
-	    long v = nw ( a2 ) ;
-	    if ( last_use ( a1 ) ) {
+	if (wh2 == Dreg && last_use(a2)) {
-		and ( sha, a2, a1, a1 ) ;
+		and(sha, a1, a2, a2);
-		return ;
-	    }
-	    if ( is_pow2 ( v ) && sz == 32 ) {
-		long n = log2 ( v ) ;
-		ins2n ( m_btstl, n, sz, a1, 1 ) ;
-		have_cond = 0 ;
-		return ;
+		return;
-	    }
+	}
-    }
-    if ( wh1 == Dreg && last_use ( a1 ) ) {
-	and ( sha, a2, a1, a1 ) ;
+	move(sha, a1, D0);
-	return ;
-    }
-    if ( wh2 == Dreg && last_use ( a2 ) ) {
-	and ( sha, a1, a2, a2 ) ;
+	and(sha, a2, D0, D0);
-	return ;
+	return;
-    }
-    move ( sha, a1, D0 ) ;
-    and ( sha, a2, D0, D0 ) ;
-    return ;
+}

Subversion Repositories tendra.SVN

(root)/trunk/src/installers/680x0/common/ops_logic.c – Rev 2 → 7