WebSVN – tendra.SVN – Diff – /branches/tendra5/src/installers/amd64/common/codec.c

 /* PROCEDURES */
 /* returns true if is_o(e) but not a possible 80386 operand */
-int
+int is_crc
-is_crc(exp e)
+(exp e)
+{
-/* process the binary logical operation exp. op is the compiling procedure for
-   the operation. It is commutative and associative, the operation takes a
+/* if a is a negation form b-son(a)
-   variable number of arguments. It is therefore necessary to avoid the mistake
-   of assigning to the destination (dest) inappropriately if its value is used
-   in the expression. At most one of the arguments will not be a possible 80386
-   operand. If there is such an argument, logop precomputes it, putting the
-   value into reg0. */
+   otherwise b+a in dest */
-static void
+static void addsub
-logop(void(*op)(shape, where, where, where), exp e, where dest, ash stack)
+(shape sha, where a, where b, where dest, exp e)
+{
-	exp arg1 = son(e);
+  UNUSED(e);
-	exp arg2 = bro(arg1);
+  if (name(a.where_exp) == neg_tag)
-	shape sha = sh(e);
+    sub(sha, mw(son(a.where_exp), 0), b, dest);
-	exp t, u;
+  else
-	where qw;
-	if (last(arg1)) {
-		coder(dest, stack, arg1);
+    add(sha, a, b, dest);
-		return;
+  return;
-	}
+}
-	/* just two arguments. */
-	if (last (arg2)) {
-		bop(op, sha, arg1, arg2, dest, stack);
-		return;
-	}
-	/* need to take care about overlap between dest and args or to avoid
-	   extra push. So use reg0. */
-	qw.where_exp = copyexp(reg0.where_exp);
-	sh(qw.where_exp) = sha;
-	qw.where_off = 0;
-	t = arg1;
-	/* now look for an argument which is not a possible 80386 operand */
-	while (1) {
-		if (!is_o(name(t)) || is_crc(t)) {
-			break;
-		}
-		if (last(t)) {
-			t = nilexp;
-			break;
-		}
-		t = bro(t);
-	}
-	/* all arguments are possible 80386 operands */
-	if (t == nilexp) {
-		(*op)(sha, mw(arg1, 0), mw(arg2, 0), qw);
-		t = bro(arg2);
-		while (!last(t)) {
-			/* encode operations in turn */
-			(*op) (sha, mw (t, 0), qw, qw);
-			t = bro(t);
-		}
-		/* encode final operation */
-		(*op) (sha, mw (t, 0), qw, dest);
-		retcell(qw.where_exp);
-		cond1_set = 0;
-		return;
-	}
-	/* encode the single argument which is not a possible 80386 operend */
+/***********************************************************************
-	coder (qw, stack, t);
-	u = arg1;
-	/* now encode the remaining operations */
+   codec outputs the code which evaulates e and puts the result into
-	while (1) {
+   dest.
-		if (t != u) {
-			if (last(u) || (bro(u) == t && last(bro(u)))) {
+ ***********************************************************************/
-				(*op)(sha, mw(u, 0), qw, dest);
-			} else {
-				(*op)(sha, mw(u, 0), qw, qw);
-			}
-		}
-		if (last(u)) {
-			break;
-		}
-		u = bro(u);
-	}
-	retcell(qw.where_exp);
-	cond1_set = 0;
-	return;
-}
-/* process the multiply operation exp. op is the compiling procedure for
+/* encode e, putting the result into dest.
-   the operation. It is commutative and associative, the operation takes a
-   variable number of arguments. It is therefore necessary to avoid the mistake
-   of assigning to the destination (dest) inappropriately if its value is used
-   in the expression. At most one of the arguments will not be a possible 80386
-   operand. If there is such an argument, it is precomputed, putting the value
-   into reg0. */
+   stack is the current stack level */
-static void
+void codec
-multop(void(*op)(shape, where, where, where), exp e, where dest, ash stack)
+(where dest, ash stack, exp e)
+{
+  switch (name(e)) {
+    case plus_tag:
+      {				/* at most one of the arguments will not
+				   be a possible 80386 operand */
 	exp arg1 = son(e);
 	exp arg2 = bro(arg1);
-	exp t, u;
+	exp t, u, v;
 	where qw;
+	exp old_overflow_e = overflow_e;
-	if (last(arg1)) {
+	if (last (arg1)) {	/* there is only one argument */
-		coder(dest, stack, arg1);
+	  coder(dest, stack, arg1);
-		return;
+	  return;
-	}
+	};
+	if (!optop(e))
+          overflow_e = e;
+	if (last(arg2) && is_o(name(arg1)) && !is_crc(arg1) &&
+	   ((is_o(name(arg2)) && !is_crc(arg2)) ||
+	     (name(arg2) == neg_tag &&
+	       !is_crc(son(arg2)) &&
+	       is_o(name(son(arg2)))))) {
-	/* just two arguments. */
+	  /* just two arguments. */
-	if (last (arg2)) {
+	  addsub(sh(e), mw(arg2, 0), mw(arg1, 0), dest, e);
-		bop(op, sh(e), arg1, arg2, dest, stack);
+          overflow_e = old_overflow_e;
-		return;
+	  return;
-	}
+	};
-	/* need to take care about overlap between dest and args or to avoid
+	/* need to take care about overlap between dest and args or to
-	   extra push. So use reg0. */
+	   avoid extra push. So use reg0. */
+	t = arg1;
 	qw.where_exp = copyexp(reg0.where_exp);
 	sh(qw.where_exp) = sh(e);
 	qw.where_off = 0;
-	t = arg1;
-	/* now look for an argument which is not a possible 80386 operand */
+	/* now look for argument which is not a possible 80386 operand */
 	while (1) {
-		if (!is_o(name(t)) || is_crc(t)) {
+	  if ((!is_o(name(t)) || is_crc(t)) &&
+	     (name(t)!= neg_tag || !is_o(name(son(t))) ||
+	       is_crc(son(t))))
-			break;
+	    break;
-		}
-		if (last(t)) {
+	  if (last(t)) {
-			t = nilexp;
+	    t = nilexp;
-			break;
+	    break;
-		}
+	  };
-		t = bro(t);
+	  t = bro(t);
-	}
+	};
+	if (t == nilexp && name(arg1) == neg_tag &&
+	    name(arg2) == neg_tag)
+	  t = arg1;
-	/* all arguments are possible 80386 operands */
+	if (t == nilexp) {	/* all arguments are possible 80386
+				   operands */
-	if (t == nilexp) {
+	  t = bro(arg2);
+	  if (name(arg1) == neg_tag)
-		(*op)(sh(e), mw(arg1, 0), mw(arg2, 0), qw);
+	    addsub(sh(e), mw(arg1, 0), mw(arg2, 0),
+		(t == e)? dest : qw, e);
+	  else
+	    addsub(sh(e), mw(arg2, 0), mw(arg1, 0),
+		(t == e)? dest : qw, e);
+	  if (t == e)
+           {
+             overflow_e = old_overflow_e;
-		t = bro(arg2);
+	     return;
+           };
-		while (!last(t)) {
+	  while (!last(t)) {
-			/* encode operations in turn */
+	    u = bro(t);
-			(*op) (sh (e), mw (t, 0), qw, qw);
+	    addsub(sh(e), mw(t, 0), qw, qw, e);
-			t = bro(t);
+	    t = u;
-		}
+	  };
-		/* encode final operation */
-		(*op) (sh (e), mw (t, 0), qw, dest);
+	  addsub(sh(e), mw(t, 0), qw, dest, e);
-		retcell(qw.where_exp);
+          overflow_e = old_overflow_e;
-		cond1_set = 0;
-		return;
+	  return;
-	}
+	};
-	/* encode the single argument which is not a possible 80386 operend */
+	coder (qw, stack, t);	/* encode the argument which is not a
-	coder (qw, stack, t);
+				   possible 80386 operand */
 	u = arg1;
 	/* now encode the remaining operations */
 	while (1) {
+	  v = bro(u);
-		if (t != u) {
+	  if (t != u) {
-			if (last(u) || (bro(u) == t && last(bro(u)))) {
+	    if (last(u) || (v == t && last(v)))
-				(*op)(sh(e), mw(u, 0), qw, dest);
+	      addsub(sh(e), mw(u, 0), qw, dest, e);
-			} else {
+	    else
-				(*op)(sh(e), mw(u, 0), qw, qw);
+	      addsub(sh(e), mw(u, 0), qw, qw, e);
-			}
+	  };
-		}
-		if (last(u)) {
+	  if (last(u))
-			break;
+	    break;
-		}
-		u = bro(u);
+	  u = v;
-	}
+	};
 	retcell(qw.where_exp);
-	cond1_set = 0;
+        cond1_set = 0;
+        overflow_e = old_overflow_e;
+	return;
+      };
+    case addptr_tag: {		/* use index operation */
+	mova(mw(e, 0), dest);
+	return;
+      };
+    case chvar_tag: {
+	exp a = son(e);
+	exp old_overflow_e = overflow_e;
+        if (!optop(e))
+          overflow_e = e;
+	if (!is_o(name(a)) || is_crc(a)) {
+				/* argument is not a possible 80386
+				   operand, so evaluate it in reg0 */
+	  if (inmem(dest) ||
+		(shape_size(sh(a)) == 8 && bad_from_reg(dest)) ||
+		shape_size(sh(a)) == 64) {
+	    where qw;
+	    qw.where_exp = copyexp(reg0.where_exp);
+	    sh(qw.where_exp) = sh(a);
+	    qw.where_off = 0;
+	    coder(qw, stack, a);
+	    change_var_check(sh(e), qw, dest);
+	    overflow_e = old_overflow_e;
+	    retcell(qw.where_exp);
+            cond1_set = 0;
+	    return;
+	  };
+	  coder(dest, stack, a);
+	  if (name(sh(e)) > name(sh(a)))
+	    change_var_sh(sh(e), sh(a), dest, dest);
+	  overflow_e = old_overflow_e;
+	  return;
+	};
+	change_var_check(sh(e), mw(a, 0), dest);
+	overflow_e = old_overflow_e;
+	return;
+      };
+    case minus_tag:
+      {
+	exp old_overflow_e = overflow_e;
+        if (!optop(e))
+          overflow_e = e;
+	bop(sub, sh(e), bro(son(e)), son(e), dest, stack);
+	overflow_e = old_overflow_e;
+	return;
+      };
+    case subptr_tag:
+    case minptr_tag:
+    case make_stack_limit_tag:
+      {
+	bop(sub, sh(e), bro(son(e)), son(e), dest, stack);
+	return;
+      };
+    case mult_tag:
+      {
+        if (!optop(e))
+          {
+	    exp old_overflow_e = overflow_e;
+            overflow_e = e;
+	    multop(multiply, e, dest, stack);
+            overflow_e = old_overflow_e;
+          }
+        else
+	  multop(mult, e, dest, stack);
+	return;
+      };
+    case div2_tag:
+      {
+	exp old_overflow_e = overflow_e;
+        if (errhandle(e))
+          overflow_e = e;
+	bop(div2, sh(e), bro(son(e)), son(e), dest, stack);
+	overflow_e = old_overflow_e;
+	return;
+      };
+    case div1_tag:
+      {
+	exp old_overflow_e = overflow_e;
+        if (errhandle(e))
+          overflow_e = e;
+	bop(div1, sh(e), bro(son(e)), son(e), dest, stack);
+	overflow_e = old_overflow_e;
+	return;
+      };
+    case div0_tag:
+      {
+	exp old_overflow_e = overflow_e;
+        if (errhandle(e))
+          overflow_e = e;
+	bop(div0, sh(e), bro(son(e)), son(e), dest, stack);
+	overflow_e = old_overflow_e;
+	return;
+      };
+    case neg_tag:
+      {
+	exp old_overflow_e = overflow_e;
+        if (!optop(e))
+          overflow_e = e;
+	uop(negate, sh(e), son(e), dest, stack);
+	overflow_e = old_overflow_e;
+	return;
+      };
+    case shl_tag:
+      {
+	exp old_overflow_e = overflow_e;
+	overflow_e = e;
+        if (!optop(e))
+          overflow_e = e;
+	bop(shiftl, sh(e), bro(son(e)), son(e), dest, stack);
+	overflow_e = old_overflow_e;
+	return;
+      };
+    case shr_tag:
+      {
+	bop(shiftr, sh(e), bro(son(e)), son(e), dest, stack);
+	return;
+      };
+    case rotl_tag:
+      {
+	bop(rotatel, sh(e), bro(son(e)), son(e), dest, stack);
 	return;
-}
+      };
-/* if a is a negation form b-son(a) otherwise b+a in dest */
+    case rotr_tag:
-static void
+      {
-addsub(shape sha, where a, where b, where dest, exp e)
+	bop(rotater, sh(e), bro(son(e)), son(e), dest, stack);
-{
+	return;
-	UNUSED(e);
+      };
+    case mod_tag:
+      {
-	if (name(a.where_exp) == neg_tag) {
+	exp old_overflow_e = overflow_e;
-		sub(sha, mw(son(a.where_exp), 0), b, dest);
+        if (errhandle(e))
-	} else {
+          overflow_e = e;
+	bop(mod, sh(e), bro(son(e)), son(e), dest, stack);
-		add(sha, a, b, dest);
+	overflow_e = old_overflow_e;
-	}
 	return;
-}
-/***********************************************************************
-   codec outputs the code which evaulates e and puts the result into
-   dest.
+      };
- ***********************************************************************/
-/* encode e, putting the result into dest.  stack is the current stack level */
-void
-codec(where dest, ash stack, exp e)
-{
-	switch (name(e)) {
-	case plus_tag: {
-		/* at most one of the arguments will not be a possible 80386
-		 * operand */
-		exp arg1 = son(e);
-		exp arg2 = bro(arg1);
-		exp t, u, v;
-		where qw;
-		exp old_overflow_e = overflow_e;
-		if (last (arg1)) {
-			/* there is only one argument */
-			coder(dest, stack, arg1);
-			return;
-		}
-		if (!optop(e)) {
-			overflow_e = e;
-		}
-		if (last(arg2) && is_o(name(arg1)) && !is_crc(arg1) &&
-		    ((is_o(name(arg2)) && !is_crc(arg2)) ||
-		     (name(arg2) == neg_tag && !is_crc(son(arg2)) &&
-		      is_o(name(son(arg2)))))) {
-			/* just two arguments. */
-			addsub(sh(e), mw(arg2, 0), mw(arg1, 0), dest, e);
-			overflow_e = old_overflow_e;
-			return;
-		}
-		/* need to take care about overlap between dest and
-		 * args or to avoid extra push. So use reg0. */
-		t = arg1;
-		qw.where_exp = copyexp(reg0.where_exp);
-		sh(qw.where_exp) = sh(e);
-		qw.where_off = 0;
-		/* now look for argument which is not a possible 80386
-		 * operand */
-		while (1) {
-			if ((!is_o(name(t)) || is_crc(t)) &&
-			    (name(t) != neg_tag || !is_o(name(son(t))) ||
-			     is_crc(son(t)))) {
-				break;
-			}
-			if (last(t)) {
-				t = nilexp;
-				break;
-			}
-			t = bro(t);
-		}
-		if (t == nilexp && name(arg1) == neg_tag &&
-		    name(arg2) == neg_tag) {
-			t = arg1;
-		}
-		/* all arguments are possible 80386 operands */
-		if (t == nilexp) {
-			t = bro(arg2);
-			if (name(arg1) == neg_tag) {
-				addsub(sh(e), mw(arg1, 0), mw(arg2, 0),
-				       (t == e) ? dest : qw, e);
-			} else {
-				addsub(sh(e), mw(arg2, 0), mw(arg1, 0),
-				       (t == e) ? dest : qw, e);
-			}
-			if (t == e) {
-				overflow_e = old_overflow_e;
-				return;
-			}
-			while (!last(t)) {
-				u = bro(t);
-				addsub(sh(e), mw(t, 0), qw, qw, e);
-				t = u;
-			}
-			addsub(sh(e), mw(t, 0), qw, dest, e);
-			overflow_e = old_overflow_e;
-			return;
-		}
-		/* encode the argument which is not a possible 80386
-		 * operand */
-		coder (qw, stack, t);
-		u = arg1;
-		/* now encode the remaining operations */
-		while (1) {
-			v = bro(u);
-			if (t != u) {
-				if (last(u) || (v == t && last(v))) {
-					addsub(sh(e), mw(u, 0), qw, dest, e);
-				} else {
-					addsub(sh(e), mw(u, 0), qw, qw, e);
-				}
-			}
-			if (last(u)) {
-				break;
-			}
-			u = v;
-		}
-		retcell(qw.where_exp);
-		cond1_set = 0;
-		overflow_e = old_overflow_e;
-		return;
-	}
-	case addptr_tag:
+    case rem2_tag:
-		/* use index operation */
-		mova(mw(e, 0), dest);
-		return;
-	case chvar_tag: {
-		exp a = son(e);
-		exp old_overflow_e = overflow_e;
-		if (!optop(e)) {
-			overflow_e = e;
-		}
-		if (!is_o(name(a)) || is_crc(a)) {
-			/* argument is not a possible 80386 operand, so
-			 * evaluate it in reg0 */
-			if (inmem(dest) ||
-			    (shape_size(sh(a)) == 8 && bad_from_reg(dest)) ||
-			    shape_size(sh(a)) == 64) {
-				where qw;
-				qw.where_exp = copyexp(reg0.where_exp);
-				sh(qw.where_exp) = sh(a);
-				qw.where_off = 0;
-				coder(qw, stack, a);
-				change_var_check(sh(e), qw, dest);
-				overflow_e = old_overflow_e;
-				retcell(qw.where_exp);
-				cond1_set = 0;
-				return;
-			}
-			coder(dest, stack, a);
-			if (name(sh(e)) > name(sh(a)))
-				change_var_sh(sh(e), sh(a), dest, dest);
-			overflow_e = old_overflow_e;
-			return;
-		}
-		change_var_check(sh(e), mw(a, 0), dest);
-		overflow_e = old_overflow_e;
-		return;
-	}
-	case minus_tag: {
-		exp old_overflow_e = overflow_e;
-		if (!optop(e)) {
-			overflow_e = e;
-		}
-		bop(sub, sh(e), bro(son(e)), son(e), dest, stack);
-		overflow_e = old_overflow_e;
-		return;
-	}
-	case subptr_tag:
-	case minptr_tag:
-	case make_stack_limit_tag:
-		bop(sub, sh(e), bro(son(e)), son(e), dest, stack);
-		return;
-	case mult_tag: {
-		if (!optop(e)) {
-			exp old_overflow_e = overflow_e;
-			overflow_e = e;
-			multop(multiply, e, dest, stack);
-			overflow_e = old_overflow_e;
-		} else {
+      {
-			multop(mult, e, dest, stack);
-		}
-		return;
-	}
-	case div2_tag: {
-		exp old_overflow_e = overflow_e;
+	exp old_overflow_e = overflow_e;
-		if (errhandle(e)) {
+        if (errhandle(e))
-			overflow_e = e;
+          overflow_e = e;
-		}
-		bop(div2, sh(e), bro(son(e)), son(e), dest, stack);
+	bop(rem2, sh(e), bro(son(e)), son(e), dest, stack);
-		overflow_e = old_overflow_e;
-		return;
-	}
-	case div1_tag: {
-		exp old_overflow_e = overflow_e;
-		if (errhandle(e)) {
-			overflow_e = e;
-		}
-		bop(div1, sh(e), bro(son(e)), son(e), dest, stack);
-		overflow_e = old_overflow_e;
-		return;
-	}
-	case div0_tag: {
-		exp old_overflow_e = overflow_e;
-		if (errhandle(e)) {
-			overflow_e = e;
-		}
-		bop(div0, sh(e), bro(son(e)), son(e), dest, stack);
-		overflow_e = old_overflow_e;
-		return;
-	}
-	case neg_tag: {
-		exp old_overflow_e = overflow_e;
-		if (!optop(e)) {
-			overflow_e = e;
-		}
-		uop(negate, sh(e), son(e), dest, stack);
-		overflow_e = old_overflow_e;
-		return;
-	}
-	case shl_tag: {
-		exp old_overflow_e = overflow_e;
-		overflow_e = e;
-		if (!optop(e)) {
-			overflow_e = e;
-		}
-		bop(shiftl, sh(e), bro(son(e)), son(e), dest, stack);
-		overflow_e = old_overflow_e;
+	overflow_e = old_overflow_e;
-		return;
-	}
-	case shr_tag:
-		bop(shiftr, sh(e), bro(son(e)), son(e), dest, stack);
-		return;
+	return;
-	case rotl_tag:
-		bop(rotatel, sh(e), bro(son(e)), son(e), dest, stack);
-		return;
+      };
-	case rotr_tag:
+    case rem0_tag:
-		bop(rotater, sh(e), bro(son(e)), son(e), dest, stack);
-		return;
+      {
-	case mod_tag: {
-		exp old_overflow_e = overflow_e;
+	exp old_overflow_e = overflow_e;
-		if (errhandle(e)) {
+        if (errhandle(e))
-			overflow_e = e;
+          overflow_e = e;
-		}
-		bop(mod, sh(e), bro(son(e)), son(e), dest, stack);
+	bop(rem0, sh(e), bro(son(e)), son(e), dest, stack);
-		overflow_e = old_overflow_e;
+	overflow_e = old_overflow_e;
-		return;
+	return;
-	}
-	case rem2_tag: {
-		exp old_overflow_e = overflow_e;
-		if (errhandle(e)) {
-			overflow_e = e;
-		}
-		bop(rem2, sh(e), bro(son(e)), son(e), dest, stack);
-		overflow_e = old_overflow_e;
-		return;
+      };
-	}
-	case rem0_tag: {
+    case round_tag:
-		exp old_overflow_e = overflow_e;
-		if (errhandle(e)) {
-			overflow_e = e;
-		}
-		bop(rem0, sh(e), bro(son(e)), son(e), dest, stack);
-		overflow_e = old_overflow_e;
-		return;
+      {
-	}
-	case round_tag: {
-		shape s = sh(e);
+	shape s = sh(e);
-		where d;
+	where d;
-		d = dest;
+	d = dest;
-		if (shape_size(s) < 32) {
+	if (shape_size(s) < 32) {
-			s = slongsh;
+	  s = slongsh;
-			if (inmem(dest)) {
+	  if (inmem(dest))
-				d = reg0;
+	    d = reg0;
-			}
-		}
-		setup_fl_ovfl(e);
-		switch (round_number(e)) {
-		case 0:
-			uop(frnd0, s, son(e), d, stack);
-			break;
-		case 1:
-			uop(frnd1, s, son(e), d, stack);
-			break;
-		case 2:
-			uop(frnd2, s, son(e), d, stack);
-			break;
-		case 3:
-			uop(frnd3, s, son(e), d, stack);
-			break;
-		case 4:
-			uop(frnd4, s, son(e), d, stack);
-			break;
-		}
-		test_fl_ovfl(e, d);
-		if (name(s) != name(sh(e))) {
-			exp old_overflow_e = overflow_e;
-			if (!optop(e)) {
-				overflow_e = e;
-			}
-			change_var_sh(sh(e), s, d, dest);
-			overflow_e = old_overflow_e;
-		}
-		return;
+	}
-	case fplus_tag:
-		setup_fl_ovfl(e);
+        setup_fl_ovfl(e);
-		fl_multop(fplus_tag, sh(e), son(e), dest);
-		test_fl_ovfl(e, dest);
-		return;
-	case fmult_tag:
-		setup_fl_ovfl(e);
-		fl_multop(fmult_tag, sh(e), son(e), dest);
-		test_fl_ovfl(e, dest);
-		return;
-	case fminus_tag:
-		setup_fl_ovfl(e);
-		fl_binop(fminus_tag, sh(e), mw(bro(son(e)), 0), mw(son(e), 0),
-			 dest, bro(son(e)));
-		test_fl_ovfl(e, dest);
-		return;
-	case fdiv_tag:
-		setup_fl_ovfl(e);
-		fl_binop(fdiv_tag, sh(e), mw(bro(son(e)), 0), mw(son(e), 0),
-			 dest, bro(son(e)));
+	switch (round_number(e)) {
-		test_fl_ovfl(e, dest);
-		return;
-	case fneg_tag:
-		setup_fl_ovfl(e);
-		fl_neg(sh(e), mw(son(e), 0), dest);
-		test_fl_ovfl(e, dest);
-		return;
-	case fabs_tag:
+	  case 0:
-		setup_fl_ovfl(e);
-		fl_abs(sh(e), mw(son(e), 0), dest);
-		test_fl_ovfl(e, dest);
-		return;
-	case float_tag:
-		setup_fl_ovfl(e);
-		floater(sh(e), mw(son(e), 0), dest);
+		uop(frnd0, s, son(e), d, stack);
-		test_fl_ovfl(e, dest);
-		return;
-	case chfl_tag:
-		if (name(sh(e)) < name(sh(son(e)))) {
-			setup_fl_ovfl(e);
-		}
-		changefl(sh(e), mw(son(e), 0), dest);
-		if (name(sh(e)) < name(sh(son(e)))) {
-			test_fl_ovfl(e, dest);
-		}
-		return;
+		break;
-	case and_tag:
+	  case 1:
-		logop(and, e, dest, stack);
+		uop(frnd1, s, son(e), d, stack);
-		return;
+		break;
-	case or_tag:
+	  case 2:
-		logop(or, e, dest, stack);
+		uop(frnd2, s, son(e), d, stack);
-		return;
+		break;
-	case xor_tag:
+	  case 3:
-		logop(xor, e, dest, stack);
+		uop(frnd3, s, son(e), d, stack);
-		return;
+		break;
-	case not_tag:
+	  case 4:
-		uop(not, sh(e), son(e), dest, stack);
+		uop(frnd4, s, son(e), d, stack);
-		return;
+		break;
-	case offset_pad_tag:
-		if (al2(sh(son(e))) >= al2(sh(e))) {
-			if (al2(sh(e)) != 1 || al2(sh(son(e))) == 1) {
-				coder(dest, stack, son(e));
-			} else {
-				coder(reg0, stack, son(e));
-				shiftl(slongsh, mw(zeroe, 3), reg0, dest);
-			}
+	};
-		} else {
-			int al = al2(sh(e)) /8;
+        test_fl_ovfl(e, d);
-			coder(reg0, stack, son(e));
-			if (al2(sh(son(e))) == 1) {
+	if (name(s)!= name(sh(e))) {
-				add(slongsh, mw(zeroe, al*8 -1), reg0, reg0);
-				shiftr(slongsh, mw(zeroe, 3), reg0, reg0);
-			} else {
-				add(slongsh, mw(zeroe, al-1), reg0, reg0);
-			}
-			and(slongsh, mw(zeroe, -al), reg0, dest);
-		}
-		return;
-	case offset_add_tag:
-		bop(add, sh(e), son(e), bro(son(e)), dest, stack);
-		return;
-	case abs_tag: {
-		exp old_overflow_e = overflow_e;
+	  exp old_overflow_e = overflow_e;
-		if (!optop(e)) {
+          if (!optop(e))
-			overflow_e = e;
+            overflow_e = e;
-		}
-		uop(absop, sh(e), son(e), dest, stack);
+	  change_var_sh(sh(e), s, d, dest);
-		overflow_e = old_overflow_e;
+	  overflow_e = old_overflow_e;
-		return;
+	}
+	/* other values */
-		/* other values */
-		if (name(e) != top_tag && name(e) != prof_tag) {
+	if (name(e)!= top_tag && name(e)!= prof_tag)
-			move(sh(e), mw(e, 0), dest);
+	  move(sh(e), mw(e, 0), dest);
-		} else {
+	else
-			top_regsinuse = regsinuse;
+	  top_regsinuse = regsinuse;
-		}
+	return;
-		return;
+      };
-	}
+  };
+}

Subversion Repositories tendra.SVN

(root)/branches/tendra5/src/installers/amd64/common/codec.c – Rev 6 → 118