Copied 8g/6g into 5g. Used sharp tools to coax a .5 file out

of 5g. 5l balks at the output and running 5g with -S shows
the true extent of the disaster. Still, better than
yesterday. Maybe.

Tested on the canonical:

package main
func main() {
}

R=rsc
APPROVED=rsc
DELTA=4182  (4181 added, 0 deleted, 1 changed)
OCL=27601
CL=28175

src/cmd/5g/Makefile

+# Copyright 2009 The Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+include ../../Make.conf
+
+TARG=\
+	5g
+
+HFILES=\
+	../gc/go.h\
+	../5l/5.out.h\
+	gg.h\
+#	opt.h\
+
+OFILES=\
+	../5l/enam.$O\
+	list.$O\
+	align.$O\
+	obj.$O\
+	gen.$O\
+	gsubr.$O\
+	cgen.$O\
+#	peep.$O\
+#	reg.$O\
+
+LIB=\
+	../gc/gc.a$O
+
+$(TARG): $(OFILES) $(LIB)
+	$(LD) -o $(TARG) -L$(GOROOT)/lib $(OFILES) $(LIB) -lbio -l9 -lm
+
+$(OFILES): $(HFILES)
+
+clean:
+	rm -f $(OFILES) $(TARG) *.5 enam.c 5.out a.out
+
+install: $(TARG)
+	cp $(TARG) $(BIN)/$(TARG)

src/cmd/5g/align.c

+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "gg.h"
+
+int	thechar	= '5';
+char*	thestring	= "arm";
+
+
+/*
+ * go declares several platform-specific type aliases:
+ * int, uint, float, and uintptr
+ */
+Typedef	typedefs[] =
+{
+	"int",		TINT,		TINT32,
+	"uint",		TUINT,		TUINT32,
+	"uintptr",	TUINTPTR,	TUINT32,
+	"float",	TFLOAT,		TFLOAT32,
+	0
+};
+
+void
+betypeinit(void)
+{
+	maxround = 4;
+	widthptr = 4;
+
+	zprog.link = P;
+	zprog.as = AGOK;
+	zprog.from.type = D_NONE;
+	zprog.from.index = D_NONE;
+	zprog.from.scale = 0;
+	zprog.to = zprog.from;
+
+	listinit();
+}

src/cmd/5g/gen.c

+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#undef	EXTERN
+#define	EXTERN
+#include "gg.h"
+
+void
+compile(Node *fn)
+{
+	Plist *pl;
+	Node nod1;
+	Prog *ptxt;
+	int32 lno;
+	Type *t;
+	Iter save;
+
+	if(newproc == N) {
+		newproc = sysfunc("newproc");
+		deferproc = sysfunc("deferproc");
+		deferreturn = sysfunc("deferreturn");
+		throwindex = sysfunc("throwindex");
+		throwreturn = sysfunc("throwreturn");
+	}
+
+	if(fn->nbody == N)
+		return;
+
+	// set up domain for labels
+	labellist = L;
+
+	lno = setlineno(fn);
+
+	curfn = fn;
+	dowidth(curfn->type);
+
+	if(curfn->type->outnamed) {
+		// add clearing of the output parameters
+		t = structfirst(&save, getoutarg(curfn->type));
+		while(t != T) {
+			if(t->nname != N)
+				curfn->nbody = list(nod(OAS, t->nname, N), curfn->nbody);
+			t = structnext(&save);
+		}
+	}
+
+	hasdefer = 0;
+	walk(curfn);
+	if(nerrors != 0)
+		goto ret;
+
+	allocparams();
+
+	continpc = P;
+	breakpc = P;
+
+	pl = newplist();
+	pl->name = curfn->nname;
+	pl->locals = autodcl;
+
+	nodconst(&nod1, types[TINT32], 0);
+	ptxt = gins(ATEXT, curfn->nname, &nod1);
+	afunclit(&ptxt->from);
+
+//	ginit();
+	gen(curfn->enter);
+	gen(curfn->nbody);
+//	gclean();
+	checklabels();
+
+//	if(curfn->type->outtuple != 0)
+//		ginscall(throwreturn, 0);
+
+//	if(hasdefer)
+//		ginscall(deferreturn, 0);
+	pc->as = ARET;	// overwrite AEND
+	pc->lineno = lineno;
+
+//	if(!debug['N'] || debug['R'] || debug['P'])
+//		regopt(ptxt);
+
+	// fill in argument size
+	ptxt->to.offset2 = rnd(curfn->type->argwid, maxround);
+
+	// fill in final stack size
+	if(stksize > maxstksize)
+		maxstksize = stksize;
+	ptxt->to.offset = rnd(maxstksize+maxarg, maxround);
+	maxstksize = 0;
+
+	if(debug['f'])
+		frame(0);
+
+ret:
+	lineno = lno;
+}
+
+void
+clearfat(Node *nl)
+{
+	fatal("clearfat");
+}
+
+/*
+ * generate:
+ *	call f
+ *	proc=0	normal call
+ *	proc=1	goroutine run in new proc
+ *	proc=2	defer call save away stack
+ */
+void
+ginscall(Node *f, int proc)
+{
+// 	Prog *p;
+// 	Node reg, con;
+
+// 	switch(proc) {
+// 	default:
+// 		fatal("ginscall: bad proc %d", proc);
+// 		break;
+
+// 	case 0:	// normal call
+// 		p = gins(ACALL, N, f);
+// 		afunclit(&p->to);
+// 		break;
+
+// 	case 1:	// call in new proc (go)
+// 	case 2:	// defered call (defer)
+// 		nodreg(&reg, types[TINT32], D_AX);
+// 		gins(APUSHL, f, N);
+// 		nodconst(&con, types[TINT32], argsize(f->type));
+// 		gins(APUSHL, &con, N);
+// 		if(proc == 1)
+// 			ginscall(newproc, 0);
+// 		else
+// 			ginscall(deferproc, 0);
+// 		gins(APOPL, N, &reg);
+// 		gins(APOPL, N, &reg);
+// 		break;
+// 	}
+}
+
+/*
+ * n is call to interface method.
+ * generate res = n.
+ */
+void
+cgen_callinter(Node *n, Node *res, int proc)
+{
+	fatal("cgen_call");
+}
+
+/*
+ * generate function call;
+ *	proc=0	normal call
+ *	proc=1	goroutine run in new proc
+ *	proc=2	defer call save away stack
+ */
+void
+cgen_call(Node *n, int proc)
+{
+	fatal("cgen_call_unimplemented");
+
+// 	Type *t;
+// 	Node nod, afun;
+
+// 	if(n == N)
+// 		return;
+
+// 	if(n->left->ullman >= UINF) {
+// 		// if name involves a fn call
+// 		// precompute the address of the fn
+// 		tempalloc(&afun, types[tptr]);
+// 		cgen(n->left, &afun);
+// 	}
+
+// 	gen(n->right);		// assign the args
+// 	t = n->left->type;
+
+// 	setmaxarg(t);
+
+// 	// call tempname pointer
+// 	if(n->left->ullman >= UINF) {
+// 		regalloc(&nod, types[tptr], N);
+// 		cgen_as(&nod, &afun);
+// 		tempfree(&afun);
+// 		nod.type = t;
+// 		ginscall(&nod, proc);
+// 		regfree(&nod);
+// 		return;
+// 	}
+
+// 	// call pointer
+// 	if(n->left->op != ONAME || n->left->class != PFUNC) {
+// 		regalloc(&nod, types[tptr], N);
+// 		cgen_as(&nod, n->left);
+// 		nod.type = t;
+// 		ginscall(&nod, proc);
+// 		regfree(&nod);
+// 		return;
+// 	}
+
+// 	// call direct
+// 	n->left->method = 1;
+// 	ginscall(n->left, proc);
+}
+
+/*
+ * call to n has already been generated.
+ * generate:
+ *	res = return value from call.
+ */
+void
+cgen_callret(Node *n, Node *res)
+{
+	fatal("cgen_callret_unimplemented");
+// 	Node nod;
+// 	Type *fp, *t;
+// 	Iter flist;
+
+// 	t = n->left->type;
+// 	if(t->etype == TPTR32 || t->etype == TPTR64)
+// 		t = t->type;
+
+// 	fp = structfirst(&flist, getoutarg(t));
+// 	if(fp == T)
+// 		fatal("cgen_callret: nil");
+
+// 	memset(&nod, 0, sizeof(nod));
+// 	nod.op = OINDREG;
+// 	nod.val.u.reg = D_SP;
+// 	nod.addable = 1;
+
+// 	nod.xoffset = fp->width;
+// 	nod.type = fp->type;
+// 	cgen_as(res, &nod);
+}
+
+/*
+ * call to n has already been generated.
+ * generate:
+ *	res = &return value from call.
+ */
+void
+cgen_aret(Node *n, Node *res)
+{
+// 	Node nod1, nod2;
+// 	Type *fp, *t;
+// 	Iter flist;
+
+// 	t = n->left->type;
+// 	if(isptr[t->etype])
+// 		t = t->type;
+
+// 	fp = structfirst(&flist, getoutarg(t));
+// 	if(fp == T)
+// 		fatal("cgen_aret: nil");
+
+// 	memset(&nod1, 0, sizeof(nod1));
+// 	nod1.op = OINDREG;
+// 	nod1.val.u.reg = D_SP;
+// 	nod1.addable = 1;
+
+// 	nod1.xoffset = fp->width;
+// 	nod1.type = fp->type;
+
+// 	if(res->op != OREGISTER) {
+// 		regalloc(&nod2, types[tptr], res);
+// 		gins(ALEAL, &nod1, &nod2);
+// 		gins(AMOVL, &nod2, res);
+// 		regfree(&nod2);
+// 	} else
+// 		gins(ALEAL, &nod1, res);
+}
+
+/*
+ * generate return.
+ * n->left is assignments to return values.
+ */
+void
+cgen_ret(Node *n)
+{
+	gen(n->left);		// copy out args
+	if(hasdefer)
+		ginscall(deferreturn, 0);
+	gins(ARET, N, N);
+}
+
+/*
+ * generate += *= etc.
+ */
+void
+cgen_asop(Node *n)
+{
+	fatal("cgen_asop");
+}
+
+/*
+ * generate division according to op, one of:
+ *	res = nl / nr
+ *	res = nl % nr
+ */
+void
+cgen_div(int op, Node *nl, Node *nr, Node *res)
+{
+	fatal("cgen_div");
+}
+
+/*
+ * generate shift according to op, one of:
+ *	res = nl << nr
+ *	res = nl >> nr
+ */
+void
+cgen_shift(int op, Node *nl, Node *nr, Node *res)
+{
+	fatal("cgen_shift");
+}
+
+/*
+ * generate byte multiply:
+ *	res = nl * nr
+ * no byte multiply instruction so have to do
+ * 16-bit multiply and take bottom half.
+ */
+void
+cgen_bmul(int op, Node *nl, Node *nr, Node *res)
+{
+	fatal("cgen_bmul");
+}

src/cmd/5g/gg.h

+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+
+#include <u.h>
+#include <libc.h>
+
+#include "../gc/go.h"
+#include "../5l/5.out.h"
+
+#ifndef	EXTERN
+#define EXTERN	extern
+#endif
+
+typedef	struct	Addr	Addr;
+
+struct	Addr
+{
+	int32	offset;
+	int32	offset2;
+
+	double	dval;
+	Prog*	branch;
+	char	sval[NSNAME];
+
+	Sym*	sym;
+	uchar	type;
+	uchar	index;
+	uchar	etype;
+	uchar	scale;	/* doubles as width in DATA op */
+};
+#define	A	((Addr*)0)
+
+struct	Prog
+{
+	short	as;		// opcode
+	uint32	loc;		// pc offset in this func
+	uint32	lineno;		// source line that generated this
+	Addr	from;		// src address
+	Addr	to;		// dst address
+	Prog*	link;		// next instruction in this func
+	void*	reg;		// pointer to containing Reg struct
+};
+
+EXTERN	Biobuf*	bout;
+EXTERN	int32	dynloc;
+EXTERN	uchar	reg[D_NONE];
+EXTERN	int32	pcloc;		// instruction counter
+/*EXTERN	String	emptystring;*/
+extern	char*	anames[];
+EXTERN	Hist*	hist;
+EXTERN	Prog	zprog;
+EXTERN	Node*	curfn;
+EXTERN	Node*	newproc;
+EXTERN	Node*	deferproc;
+EXTERN	Node*	deferreturn;
+EXTERN	Node*	throwindex;
+EXTERN	Node*	throwreturn;
+EXTERN	int	maxstksize;
+
+/*
+ * gen.c
+ */
+void	compile(Node*);
+void	proglist(void);
+void	gen(Node*);
+Node*	lookdot(Node*, Node*, int);
+void	cgen_as(Node*, Node*);
+void	cgen_callmeth(Node*, int);
+void	cgen_callinter(Node*, Node*, int);
+void	cgen_proc(Node*, int);
+void	cgen_callret(Node*, Node*);
+void	cgen_div(int, Node*, Node*, Node*);
+void	cgen_bmul(int, Node*, Node*, Node*);
+void	cgen_shift(int, Node*, Node*, Node*);
+void	cgen_dcl(Node*);
+int	needconvert(Type*, Type*);
+void	genconv(Type*, Type*);
+void	allocparams(void);
+void	checklabels();
+void	ginscall(Node*, int);
+
+/*
+ * cgen
+ */
+void	agen(Node*, Node*);
+void	igen(Node*, Node*, Node*);
+vlong	fieldoffset(Type*, Node*);
+void	bgen(Node*, int, Prog*);
+void	sgen(Node*, Node*, int32);
+void	gmove(Node*, Node*);
+Prog*	gins(int, Node*, Node*);
+int	samaddr(Node*, Node*);
+void	naddr(Node*, Addr*);
+void	cgen_aret(Node*, Node*);
+int	cgen64(Node*, Node*);
+int	is64(Type*);
+
+/*
+ * gsubr.c
+ */
+void	clearp(Prog*);
+void	proglist(void);
+Prog*	gbranch(int, Type*);
+Prog*	prog(int);
+void	gaddoffset(Node*);
+void	gconv(int, int);
+int	conv2pt(Type*);
+vlong	convvtox(vlong, int);
+void	fnparam(Type*, int, int);
+Prog*	gop(int, Node*, Node*, Node*);
+void	setconst(Addr*, vlong);
+void	setaddr(Addr*, Node*);
+int	optoas(int, Type*);
+void	ginit(void);
+void	gclean(void);
+void	regalloc(Node*, Type*, Node*);
+void	regfree(Node*);
+void	tempalloc(Node*, Type*);
+void	tempfree(Node*);
+Node*	nodarg(Type*, int);
+void	nodreg(Node*, Type*, int);
+void	nodindreg(Node*, Type*, int);
+void	nodconst(Node*, Type*, int64);
+void	gconreg(int, vlong, int);
+void	buildtxt(void);
+Plist*	newplist(void);
+int	isfat(Type*);
+void	sudoclean(void);
+int	sudoaddable(Node*, Addr*);
+void	afunclit(Addr*);
+
+/*
+ * list.c
+ */
+int	Aconv(Fmt*);
+int	Dconv(Fmt*);
+int	Pconv(Fmt*);
+int	Rconv(Fmt*);
+int	Yconv(Fmt*);
+void	listinit(void);
+
+void	zaddr(Biobuf*, Addr*, int);

src/cmd/5g/list.c

+// Derived from Inferno utils/5c/list.c
+// http://code.google.com/p/inferno-os/source/browse/utils/5c/list.c
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors.  All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#include "gg.h"
+
+static	int	sconsize;
+void
+listinit(void)
+{
+
+	fmtinstall('A', Aconv);		// as
+	fmtinstall('P', Pconv);		// Prog*
+	fmtinstall('D', Dconv);		// Addr*
+	fmtinstall('R', Rconv);		// reg
+	fmtinstall('Y', Yconv);		// sconst
+}
+
+int
+Pconv(Fmt *fp)
+{
+	char str[STRINGSZ];
+	Prog *p;
+
+	p = va_arg(fp->args, Prog*);
+	sconsize = 8;
+	switch(p->as) {
+	default:
+		snprint(str, sizeof(str), "%.4ld (%4ld) %-7A %D,%D",
+			p->loc, p->lineno, p->as, &p->from, &p->to);
+		break;
+
+	case ADATA:
+		sconsize = p->from.scale;
+		snprint(str, sizeof(str), "%.4ld (%4ld) %-7A %D/%d,%D",
+			p->loc, p->lineno, p->as, &p->from, sconsize, &p->to);
+		break;
+
+	case ATEXT:
+		snprint(str, sizeof(str), "%.4ld (%4ld) %-7A %D,%lD",
+			p->loc, p->lineno, p->as, &p->from, &p->to);
+		break;
+	}
+	return fmtstrcpy(fp, str);
+}
+
+int
+Dconv(Fmt *fp)
+{
+	char str[100], s[100];
+	Addr *a;
+	int i;
+	uint32 d1, d2;
+
+	a = va_arg(fp->args, Addr*);
+	i = a->type;
+// TODO(kaib): add back
+// 	if(i >= D_INDIR) {
+// 		if(a->offset)
+// 			snprint(str, sizeof(str), "%ld(%R)", a->offset, i-D_INDIR);
+// 		else
+// 			snprint(str, sizeof(str), "(%R)", i-D_INDIR);
+// 		goto brk;
+// 	}
+	switch(i) {
+
+	default:
+		if(a->offset)
+			snprint(str, sizeof(str), "$%ld,%R", a->offset, i);
+		else
+			snprint(str, sizeof(str), "%R", i);
+		break;
+
+	case D_NONE:
+		str[0] = 0;
+		break;
+
+	case D_BRANCH:
+		snprint(str, sizeof(str), "%ld", a->branch->loc);
+		break;
+
+	case D_EXTERN:
+		snprint(str, sizeof(str), "%S+%ld(SB)", a->sym, a->offset);
+		break;
+
+	case D_STATIC:
+		snprint(str, sizeof(str), "%S<>+%ld(SB)", a->sym, a->offset);
+		break;
+
+	case D_AUTO:
+		snprint(str, sizeof(str), "%S+%ld(SP)", a->sym, a->offset);
+		break;
+
+	case D_PARAM:
+		snprint(str, sizeof(str), "%S+%ld(FP)", a->sym, a->offset);
+		break;
+
+	case D_CONST:
+		if(fp->flags & FmtLong) {
+			d1 = a->offset;
+			d2 = a->offset2;
+			snprint(str, sizeof(str), "$%lud-%lud", (ulong)d1, (ulong)d2);
+			break;
+		}
+		snprint(str, sizeof(str), "$%ld", a->offset);
+		break;
+
+	case D_FCONST:
+		snprint(str, sizeof(str), "$(%.17e)", a->dval);
+		break;
+
+	case D_SCONST:
+		snprint(str, sizeof(str), "$\"%Y\"", a->sval);
+		break;
+
+// TODO(kaib): add back
+// 	case D_ADDR:
+// 		a->type = a->index;
+// 		a->index = D_NONE;
+// 		snprint(str, sizeof(str), "$%D", a);
+// 		a->index = a->type;
+// 		a->type = D_ADDR;
+// 		goto conv;
+	}
+brk:
+	if(a->index != D_NONE) {
+		snprint(s, sizeof(s), "(%R*%d)", (int)a->index, (int)a->scale);
+		strcat(str, s);
+	}
+conv:
+	return fmtstrcpy(fp, str);
+}
+
+static	char*	regstr[] =
+{
+	"AL",		/* [D_AL] */
+	"CL",
+	"DL",
+	"BL",
+
+	"AH",	/* [D_AH] */
+	"CH",
+	"DH",
+	"BH",
+
+	"AX",		/* [D_AX] */
+	"CX",
+	"DX",
+	"BX",
+	"SP",
+	"BP",
+	"SI",
+	"DI",
+
+	"F0",		/* [D_F0] */
+	"F1",
+	"F2",
+	"F3",
+	"F4",
+	"F5",
+	"F6",
+	"F7",
+
+	"CS",		/* [D_CS] */
+	"SS",
+	"DS",
+	"ES",
+	"FS",
+	"GS",
+
+	"GDTR",		/* [D_GDTR] */
+	"IDTR",		/* [D_IDTR] */
+	"LDTR",		/* [D_LDTR] */
+	"MSW",		/* [D_MSW] */
+	"TASK",		/* [D_TASK] */
+
+	"CR0",		/* [D_CR] */
+	"CR1",
+	"CR2",
+	"CR3",
+	"CR4",
+	"CR5",
+	"CR6",
+	"CR7",
+
+	"DR0",		/* [D_DR] */
+	"DR1",
+	"DR2",
+	"DR3",
+	"DR4",
+	"DR5",
+	"DR6",
+	"DR7",
+
+	"TR0",		/* [D_TR] */
+	"TR1",
+	"TR2",
+	"TR3",
+	"TR4",
+	"TR5",
+	"TR6",
+	"TR7",
+
+	"NONE",		/* [D_NONE] */
+};
+
+int
+Rconv(Fmt *fp)
+{
+	char str[STRINGSZ];
+	int r;
+
+	r = va_arg(fp->args, int);
+	if(r < 0 || r >= nelem(regstr) || regstr[r] == nil) {
+		snprint(str, sizeof(str), "BAD_R(%d)", r);
+		return fmtstrcpy(fp, str);
+	}
+	return fmtstrcpy(fp, regstr[r]);
+}
+
+int
+Aconv(Fmt *fp)
+{
+	int i;
+
+	i = va_arg(fp->args, int);
+	return fmtstrcpy(fp, anames[i]);
+}
+
+
+int
+Yconv(Fmt *fp)
+{
+	int i, c;
+	char str[30], *p, *a;
+
+	a = va_arg(fp->args, char*);
+	p = str;
+	for(i=0; i<sconsize; i++) {
+		c = a[i] & 0xff;
+		if((c >= 'a' && c <= 'z') ||
+		   (c >= 'A' && c <= 'Z') ||
+		   (c >= '0' && c <= '9')) {
+			*p++ = c;
+			continue;
+		}
+		*p++ = '\\';
+		switch(c) {
+		default:
+			if(c < 040 || c >= 0177)
+				break;	/* not portable */
+			p[-1] = c;
+			continue;
+		case 0:
+			*p++ = 'z';
+			continue;
+		case '\\':
+		case '"':
+			*p++ = c;
+			continue;
+		case '\n':
+			*p++ = 'n';
+			continue;
+		case '\t':
+			*p++ = 't';
+			continue;
+		}
+		*p++ = (c>>6) + '0';
+		*p++ = ((c>>3) & 7) + '0';
+		*p++ = (c & 7) + '0';
+	}
+	*p = 0;
+	return fmtstrcpy(fp, str);
+}

src/cmd/5l/5.out.h

@@ -201,7 +201,8 @@ enum	as
 
 #define	D_SHIFT		(D_NONE+19)
 #define	D_FPCR		(D_NONE+20)
-#define 	D_REGREG	(D_NONE+21)
+#define D_REGREG	(D_NONE+21)
+#define D_ADDR		(D_NONE+22)
 
 /* name */
 #define	D_EXTERN	(D_NONE+3)