8c, 6c: avoid allocating index registers when we don't have to

when a operation receives a chain of OINDEX nodes as its operands,
each indexing step used to allocate a new index register. this
is wastefull an can result in running out of fixed registers on 386
for code such as: x = a[a[a[a[i]]]].

instead we attempt to reuse the destination register of the operation
as the index register if it is not otherwise referenced. this results
in the index chain to use a single register for index and result and
leaves registers free to be used for something usefull instead.

for 6c, try to avoid R13 as well as BP index base register.

1 files changed, 20 insertions, 5 deletions

diff --git a/sys/src/cmd/8c/txt.c b/sys/src/cmd/8c/txt.c
index 9d64aa7e3..4feb0f7f4 100644
--- a/sys/src/cmd/8c/txt.c
+++ b/sys/src/cmd/8c/txt.c
@@ -928,8 +928,18 @@ gmove(Node *f, Node *t)
 	gins(a, f, t);
 }
 
+static int
+regused(Node *n, int r)
+{
+	if(n == nil)
+		return 0;
+	if(isreg(n, r))
+		return 1;
+	return regused(n->left, r) || regused(n->right, r);
+}
+
 void
-doindex(Node *n)
+doindex(Node *n, Node *o)
 {
 	Node nod, nod1;
 	long v;
@@ -940,7 +950,11 @@ prtree(n, "index");
 if(n->left->complex >= FNX)
 print("botch in doindex\n");
 
-	regalloc(&nod, &regnode, Z);
+	if(n->right->op == OREGISTER)
+		o = n->right;
+	else if(o == Z || o->op != OREGISTER || regused(n, o->reg))
+		o = Z;
+	regalloc(&nod, &regnode, o);
 	v = constnode.vconst;
 	cgen(n->right, &nod);
 	idx.ptr = D_NONE;
@@ -965,11 +979,12 @@ print("botch in doindex\n");
 void
 gins(int a, Node *f, Node *t)
 {
-
 	if(f != Z && f->op == OINDEX)
-		doindex(f);
+		doindex(f, a == AMOVL || a == ALEAL
+			|| a == AMOVBLSX || a == AMOVBLZX
+			|| a == AMOVWLSX || a == AMOVWLZX ? t : Z);
 	if(t != Z && t->op == OINDEX)
-		doindex(t);
+		doindex(t, Z);
 	nextpc();
 	p->as = a;
 	if(f != Z)