Imported Upstream version 2011.01.12upstream/2011.01.12

14 files changed, 1908 insertions, 3515 deletions

diff --git a/src/cmd/5l/5.out.h b/src/cmd/5l/5.out.h
index c06441c1c..a25c0f71d 100644
--- a/src/cmd/5l/5.out.h
+++ b/src/cmd/5l/5.out.h
@@ -58,6 +58,7 @@
 #define	NFREG		8
 #define	FREGRET		0
 #define	FREGEXT		7
+#define	FREGTMP		15
 /* compiler allocates register variables F0 up */
 /* compiler allocates external registers F7 down */
 
@@ -158,8 +159,8 @@ enum	as
 	ARET,
 	ATEXT,
 	AWORD,
-	ADYNT,
-	AINIT,
+	ADYNT_,
+	AINIT_,
 	ABCASE,
 	ACASE,
 
@@ -188,7 +189,7 @@ enum	as
 #define	C_PBIT	(1<<5)
 #define	C_WBIT	(1<<6)
 #define	C_FBIT	(1<<7)	/* psr flags-only */
-#define	C_UBIT	(1<<7)	/* up bit */
+#define	C_UBIT	(1<<7)	/* up bit, unsigned bit */
 
 #define C_SCOND_EQ	0
 #define C_SCOND_NE	1
@@ -246,6 +247,7 @@ enum	as
 
 /* internal only */
 #define	D_SIZE		(D_NONE+40)
+#define	D_PCREL		(D_NONE+41)
 
 /*
  * this is the ranlib header
diff --git a/src/cmd/5l/Makefile b/src/cmd/5l/Makefile
index b9780f098..71798724b 100644
--- a/src/cmd/5l/Makefile
+++ b/src/cmd/5l/Makefile
@@ -2,24 +2,29 @@
 # Use of this source code is governed by a BSD-style
 # license that can be found in the LICENSE file.
 
-include ../../Make.conf
+include ../../Make.inc
+O:=$(HOST_O)
 
-TARG=\
-	5l\
+TARG=5l
 
 OFILES=\
 	asm.$O\
+	data.$O\
 	elf.$O\
 	enam.$O\
+	ldelf.$O\
+	ldmacho.$O\
 	lib.$O\
 	list.$O\
 	noop.$O\
 	obj.$O\
 	optab.$O\
 	pass.$O\
+	prof.$O\
 	thumb.$O\
 	softfloat.$O\
 	span.$O\
+	symtab.$O\
 	go.$O\
 
 HFILES=\
@@ -27,19 +32,12 @@ HFILES=\
 	../5l/5.out.h\
 	../ld/elf.h\
 
-$(TARG): $(OFILES)
-	$(LD) -o $(TARG) -L"$(GOROOT)"/lib $(OFILES) -lbio -l9
-
-$(OFILES): $(HFILES)
+include ../../Make.ccmd
 
 enam.c: 5.out.h
 	sh mkenam
 
-clean:
-	rm -f *.o $(TARG) *.5 enam.c 5.out a.out
-
-install: $(TARG)
-	cp $(TARG) "$(GOBIN)"/$(TARG)
+CLEANFILES+=enam.c
 
 %.$O: ../ld/%.c
-	$(CC) $(CFLAGS) -c -I. ../ld/$*.c
+	$(HOST_CC) $(HOST_CFLAGS) -c -I. ../ld/$*.c
diff --git a/src/cmd/5l/asm.c b/src/cmd/5l/asm.c
index 45e6e734f..7ceea59b6 100644
--- a/src/cmd/5l/asm.c
+++ b/src/cmd/5l/asm.c
@@ -28,6 +28,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+// Writing object files.
+
 #include	"l.h"
 #include	"../ld/lib.h"
 #include	"../ld/elf.h"
@@ -50,127 +52,11 @@ entryvalue(void)
 	s = lookup(a, 0);
 	if(s->type == 0)
 		return INITTEXT;
-	switch(s->type) {
-	case STEXT:
-	case SLEAF:
-		break;
-	case SDATA:
-		if(dlm)
-			return s->value+INITDAT;
-	default:
+	if(s->type != STEXT)
 		diag("entry not text: %s", s->name);
-	}
 	return s->value;
 }
 
-vlong
-addstring(Sym *s, char *str)
-{
-	int n, m;
-	vlong r;
-	Prog *p;
-
-	if(s->type == 0)
-		s->type = SDATA;
-	s->reachable = 1;
-	r = s->value;
-	n = strlen(str)+1;
-	while(n > 0) {
-		m = n;
-		if(m > NSNAME)
-			m = NSNAME;
-		p = newdata(s, s->value, m, D_EXTERN);
-		p->to.type = D_SCONST;
-		p->to.sval = mal(NSNAME);
-		memmove(p->to.sval, str, m);
-		s->value += m;
-		str += m;
-		n -= m;
-	}
-	return r;
-}
-
-vlong
-adduintxx(Sym *s, uint64 v, int wid)
-{
-	vlong r;
-	Prog *p;
-
-	if(s->type == 0)
-		s->type = SDATA;
-	s->reachable = 1;
-	r = s->value;
-	p = newdata(s, s->value, wid, D_EXTERN);
-	s->value += wid;
-	p->to.type = D_CONST;
-	p->to.offset = v;
-	return r;
-}
-
-vlong
-adduint8(Sym *s, uint8 v)
-{
-	return adduintxx(s, v, 1);
-}
-
-vlong
-adduint16(Sym *s, uint16 v)
-{
-	return adduintxx(s, v, 2);
-}
-
-vlong
-adduint32(Sym *s, uint32 v)
-{
-	return adduintxx(s, v, 4);
-}
-
-vlong
-adduint64(Sym *s, uint64 v)
-{
-	return adduintxx(s, v, 8);
-}
-
-vlong
-addaddr(Sym *s, Sym *t)
-{
-	vlong r;
-	Prog *p;
-	enum { Ptrsize = 4 };
-
-	if(s->type == 0)
-		s->type = SDATA;
-	s->reachable = 1;
-	r = s->value;
-	p = newdata(s, s->value, Ptrsize, D_EXTERN);
-	s->value += Ptrsize;
-	p->to.type = D_ADDR;
-	p->to.index = D_EXTERN;
-	p->to.offset = 0;
-	p->to.sym = t;
-	return r;
-}
-
-vlong
-addsize(Sym *s, Sym *t)
-{
-	vlong r;
-	Prog *p;
-	enum { Ptrsize = 4 };
-
-	if(s->type == 0)
-		s->type = SDATA;
-	s->reachable = 1;
-	r = s->value;
-	p = newdata(s, s->value, Ptrsize, D_EXTERN);
-	s->value += Ptrsize;
-	p->to.type = D_SIZE;
-	p->to.index = D_EXTERN;
-	p->to.offset = 0;
-	p->to.sym = t;
-	return r;
-}
-
 enum {
 	ElfStrEmpty,
 	ElfStrInterp,
@@ -188,6 +74,8 @@ enum {
 	ElfStrGosymtab,
 	ElfStrGopclntab,
 	ElfStrShstrtab,
+	ElfStrRelPlt,
+	ElfStrPlt,
 	NElfStr
 };
 
@@ -209,21 +97,67 @@ needlib(char *name)
 	return 0;
 }
 
+int	nelfsym = 1;
+
+void
+adddynrel(Sym *s, Reloc *r)
+{
+	diag("adddynrel: unsupported binary format");
+}
+
+void
+adddynsym(Sym *s)
+{
+	diag("adddynsym: not implemented");
+}
+
+static void
+elfsetupplt(void)
+{
+	// TODO
+}
+
+int
+archreloc(Reloc *r, Sym *s, vlong *val)
+{
+	return -1;
+}
+
+void
+adddynlib(char *lib)
+{
+	Sym *s;
+	
+	if(!needlib(lib))
+		return;
+	
+	if(iself) {
+		s = lookup(".dynstr", 0);
+		if(s->size == 0)
+			addstring(s, "");
+		elfwritedynent(lookup(".dynamic", 0), DT_NEEDED, addstring(s, lib));
+	} else {
+		diag("adddynlib: unsupported binary format");
+	}
+}
+
 void
 doelf(void)
 {
-	Sym *s, *shstrtab, *dynamic, *dynstr, *d;
-	int h, nsym, t;
+	Sym *s, *shstrtab, *dynstr;
 
 	if(!iself)
 		return;
 
 	/* predefine strings we need for section headers */
 	shstrtab = lookup(".shstrtab", 0);
+	shstrtab->type = SELFDATA;
 	shstrtab->reachable = 1;
+
 	elfstr[ElfStrEmpty] = addstring(shstrtab, "");
 	elfstr[ElfStrText] = addstring(shstrtab, ".text");
 	elfstr[ElfStrData] = addstring(shstrtab, ".data");
+	addstring(shstrtab, ".rodata");
 	elfstr[ElfStrBss] = addstring(shstrtab, ".bss");
 	if(!debug['s']) {	
 		elfstr[ElfStrGosymcounts] = addstring(shstrtab, ".gosymcounts");
@@ -241,6 +175,8 @@ doelf(void)
 		elfstr[ElfStrDynsym] = addstring(shstrtab, ".dynsym");
 		elfstr[ElfStrDynstr] = addstring(shstrtab, ".dynstr");
 		elfstr[ElfStrRel] = addstring(shstrtab, ".rel");
+		elfstr[ElfStrRelPlt] = addstring(shstrtab, ".rel.plt");
+		elfstr[ElfStrPlt] = addstring(shstrtab, ".plt");
 
 		/* interpreter string */
 		s = lookup(".interp", 0);
@@ -257,7 +193,8 @@ doelf(void)
 		s = lookup(".dynstr", 0);
 		s->type = SELFDATA;
 		s->reachable = 1;
-		addstring(s, "");
+		if(s->size == 0)
+			addstring(s, "");
 		dynstr = s;
 
 		/* relocation table */
@@ -269,92 +206,35 @@ doelf(void)
 		s = lookup(".got", 0);
 		s->reachable = 1;
 		s->type = SELFDATA;
+		
+		/* hash */
+		s = lookup(".hash", 0);
+		s->reachable = 1;
+		s->type = SELFDATA;
 
-		/* got.plt - ??? */
+		/* got.plt */
 		s = lookup(".got.plt", 0);
 		s->reachable = 1;
-		s->type = SELFDATA;
+		s->type = SDATA;	// writable, so not SELFDATA
 		
-		/* hash */
-		s = lookup(".hash", 0);
+		s = lookup(".plt", 0);
+		s->reachable = 1;
+		s->type = SELFDATA;
+
+		s = lookup(".rel.plt", 0);
 		s->reachable = 1;
 		s->type = SELFDATA;
+		
+		elfsetupplt();
 
 		/* define dynamic elf table */
 		s = lookup(".dynamic", 0);
 		s->reachable = 1;
 		s->type = SELFDATA;
-		dynamic = s;
-
-		/*
-		 * relocation entries for dynimp symbols
-		 */
-		nsym = 1;	// sym 0 is reserved
-		for(h=0; h<NHASH; h++) {
-			for(s=hash[h]; s!=S; s=s->link) {
-				if(!s->reachable || (s->type != SDATA && s->type != SBSS) || s->dynimpname == nil)
-					continue;
-
-				if(!s->dynexport) {
-					d = lookup(".rel", 0);
-					addaddr(d, s);
-					adduint32(d, ELF32_R_INFO(nsym, R_ARM_ABS32));
-				}
-
-				nsym++;
-
-				d = lookup(".dynsym", 0);
-				adduint32(d, addstring(lookup(".dynstr", 0), s->dynimpname));
-				/* value */
-				if(!s->dynexport)
-					adduint32(d, 0);
-				else
-					addaddr(d, s);
-
-				/* size of object */
-				adduint32(d, 0);
-
-				/* type */
-				t = STB_GLOBAL << 4;
-				if(s->dynexport && s->type == STEXT)
-					t |= STT_FUNC;
-				else
-					t |= STT_OBJECT;
-				adduint8(d, t);
-
-				/* reserved */
-				adduint8(d, 0);
-
-				/* section where symbol is defined */
-				if(!s->dynexport)
-					adduint16(d, SHN_UNDEF);
-				else {
-					switch(s->type) {
-					default:
-					case STEXT:
-						t = 9;
-						break;
-					case SDATA:
-						t = 10;
-						break;
-					case SBSS:
-						t = 11;
-						break;
-					}
-					adduint16(d, t);
-				}
-
-				if(!s->dynexport && needlib(s->dynimplib))
-					elfwritedynent(dynamic, DT_NEEDED, addstring(dynstr, s->dynimplib));
-			}
-		}
-
-		elfdynhash(nsym);
 
 		/*
 		 * .dynamic table
 		 */
-		s = dynamic;
 		elfwritedynentsym(s, DT_HASH, lookup(".hash", 0));
 		elfwritedynentsym(s, DT_SYMTAB, lookup(".dynsym", 0));
 		elfwritedynent(s, DT_SYMENT, ELF32SYMSIZE);
@@ -365,6 +245,10 @@ doelf(void)
 		elfwritedynent(s, DT_RELENT, ELF32RELSIZE);
 		if(rpath)
 			elfwritedynent(s, DT_RUNPATH, addstring(dynstr, rpath));
+		elfwritedynentsym(s, DT_PLTGOT, lookup(".got.plt", 0));
+		elfwritedynent(s, DT_PLTREL, DT_REL);
+		elfwritedynentsymsize(s, DT_PLTRELSZ, lookup(".rel.plt", 0));
+		elfwritedynentsym(s, DT_JMPREL, lookup(".rel.plt", 0));
 		elfwritedynent(s, DT_NULL, 0);
 	}
 }
@@ -372,16 +256,18 @@ doelf(void)
 vlong
 datoff(vlong addr)
 {
-	if(addr >= INITDAT)
-		return addr - INITDAT + rnd(HEADR+textsize, INITRND);
-	diag("datoff %#llx", addr);
+	if(addr >= segdata.vaddr)
+		return addr - segdata.vaddr + segdata.fileoff;
+	if(addr >= segtext.vaddr)
+		return addr - segtext.vaddr + segtext.fileoff;
+	diag("datoff %#x", addr);
 	return 0;
 }
 
 void
 shsym(Elf64_Shdr *sh, Sym *s)
 {
-	sh->addr = s->value + INITDAT;
+	sh->addr = symaddr(s);
 	sh->off = datoff(sh->addr);
 	sh->size = s->size;
 }
@@ -400,103 +286,47 @@ phsh(Elf64_Phdr *ph, Elf64_Shdr *sh)
 void
 asmb(void)
 {
-	Prog *p;
-	int32 t, etext;
+	int32 t;
 	int a, dynsym;
-	uint32 va, fo, w, symo, startva;
-	uint32 symdatva = SYMDATVA;
+	uint32 va, fo, w, startva;
 	int strtabsize;
-	Optab *o;
 	ElfEhdr *eh;
 	ElfPhdr *ph, *pph;
 	ElfShdr *sh;
+	Section *sect;
 
 	strtabsize = 0;
-	symo = 0;
 
 	if(debug['v'])
-		Bprint(&bso, "%5.2f asm\n", cputime());
+		Bprint(&bso, "%5.2f asmb\n", cputime());
 	Bflush(&bso);
-	OFFSET = HEADR;
-	seek(cout, OFFSET, 0);
-	pc = INITTEXT;
-	for(p = firstp; p != P; p = p->link) {
-		setarch(p);
-		if(p->as == ATEXT) {
-			curtext = p;
-			autosize = p->to.offset + 4;
-		}
-		if(p->pc != pc) {
-			diag("phase error %lux sb %lux",
-				p->pc, pc);
-			if(!debug['a'])
-				prasm(curp);
-			pc = p->pc;
-		}
-		curp = p;
-		o = oplook(p);	/* could probably avoid this call */
-		if(thumb)
-			thumbasmout(p, o);
-		else
-			asmout(p, o);
-		pc += o->size;
-	}
-	while(pc-INITTEXT < textsize) {
-		cput(0);
-		pc++;
-	}
 
-	if(debug['a'])
-		Bprint(&bso, "\n");
-	Bflush(&bso);
-	cflush();
+	sect = segtext.sect;
+	seek(cout, sect->vaddr - segtext.vaddr + segtext.fileoff, 0);
+	codeblk(sect->vaddr, sect->len);
 
-	/* output strings in text segment */
-	etext = INITTEXT + textsize;
-	for(t = pc; t < etext; t += sizeof(buf)-100) {
-		if(etext-t > sizeof(buf)-100)
-			datblk(t, sizeof(buf)-100, 1);
-		else
-			datblk(t, etext-t, 1);
-	}
+	/* output read-only data in text segment */
+	sect = segtext.sect->next;
+	seek(cout, sect->vaddr - segtext.vaddr + segtext.fileoff, 0);
+	datblk(sect->vaddr, sect->len);
 
-	/* output section header strings */
-	curtext = P;
-	switch(HEADTYPE) {
-	case 0:
-	case 1:
-	case 2:
-	case 5:
-		OFFSET = HEADR+textsize;
-		seek(cout, OFFSET, 0);
-		break;
-	case 3:
-		OFFSET = rnd(HEADR+textsize, 4096);
-		seek(cout, OFFSET, 0);
-		break;
-	case 6:
-		OFFSET = rnd(HEADR+textsize, INITRND);
-		seek(cout, OFFSET, 0);
-		break;
-	}
-	if(dlm){
-		char buf[8];
+	if(debug['v'])
+		Bprint(&bso, "%5.2f datblk\n", cputime());
+	Bflush(&bso);
 
-		write(cout, buf, INITDAT-textsize);
-		textsize = INITDAT;
-	}
-	for(t = 0; t < datsize; t += sizeof(buf)-100) {
-		if(datsize-t > sizeof(buf)-100)
-			datblk(t, sizeof(buf)-100, 0);
-		else
-			datblk(t, datsize-t, 0);
-	}
-	cflush();
+	seek(cout, segdata.fileoff, 0);
+	datblk(segdata.vaddr, segdata.filelen);
+
+	/* output read-only data in text segment */
+	sect = segtext.sect->next;
+	seek(cout, sect->vaddr - segtext.vaddr + segtext.fileoff, 0);
+	datblk(sect->vaddr, sect->len);
 
 	/* output symbol table */
 	symsize = 0;
 	lcsize = 0;
 	if(!debug['s']) {
+		// TODO: rationalize
 		if(debug['v'])
 			Bprint(&bso, "%5.2f sym\n", cputime());
 		Bflush(&bso);
@@ -508,45 +338,24 @@ asmb(void)
 			debug['s'] = 1;
 			break;
 		case 2:
-			OFFSET = HEADR+textsize+datsize;
+			OFFSET = HEADR+textsize+segdata.filelen;
 			seek(cout, OFFSET, 0);
 			break;
 		case 3:
-			OFFSET += rnd(datsize, 4096);
+			OFFSET += rnd(segdata.filelen, 4096);
 			seek(cout, OFFSET, 0);
 			break;
 		case 6:
-			symo = rnd(HEADR+textsize, INITRND)+datsize+strtabsize;
-			symo = rnd(symo, INITRND);
-			seek(cout, symo + 8, 0);
+			OFFSET += segdata.filelen;
+			seek(cout, rnd(OFFSET, INITRND), 0);
 			break;
 		}
 		if(!debug['s'])
-			asmsym();
-		if(debug['v'])
-			Bprint(&bso, "%5.2f pc\n", cputime());
-		Bflush(&bso);
-		if(!debug['s'])
-			asmlc();
-		if(!debug['s'])
 			asmthumbmap();
-		if(dlm)
-			asmdyn();
-		if(!debug['s'])
-			strnput("", INITRND-(8+symsize+lcsize)%INITRND);
-		cflush();
-		seek(cout, symo, 0);
-		lputl(symsize);
-		lputl(lcsize);
-		cflush();
-	}
-	else if(dlm){
-		seek(cout, HEADR+textsize+datsize, 0);
-		asmdyn();
 		cflush();
 	}
 
-	curtext = P;
+	cursym = nil;
 	if(debug['v'])
 		Bprint(&bso, "%5.2f header\n", cputime());
 	Bflush(&bso);
@@ -568,10 +377,10 @@ asmb(void)
 
 		lputl(0xef000011);		/* SWI - exit code */
 		lputl(textsize+HEADR);		/* text size */
-		lputl(datsize);			/* data size */
+		lputl(segdata.filelen);			/* data size */
 		lputl(0);			/* sym size */
 
-		lputl(bsssize);			/* bss size */
+		lputl(segdata.len - segdata.filelen);			/* bss size */
 		lputl(0);			/* sym type */
 		lputl(INITTEXT-HEADR);		/* text addr */
 		lputl(0);			/* workspace - ignored */
@@ -586,13 +395,10 @@ asmb(void)
 		lputl(0xe1a0f00e);		/* B (R14) - zero init return */
 		break;
 	case 2:	/* plan 9 */
-		if(dlm)
-			lput(0x80000000|0x647);	/* magic */
-		else
-			lput(0x647);			/* magic */
+		lput(0x647);			/* magic */
 		lput(textsize);			/* sizes */
-		lput(datsize);
-		lput(bsssize);
+		lput(segdata.filelen);
+		lput(segdata.len - segdata.filelen);
 		lput(symsize);			/* nsyms */
 		lput(entryvalue());		/* va of entry */
 		lput(0L);
@@ -601,8 +407,8 @@ asmb(void)
 	case 3:	/* boot for NetBSD */
 		lput((143<<16)|0413);		/* magic */
 		lputl(rnd(HEADR+textsize, 4096));
-		lputl(rnd(datsize, 4096));
-		lputl(bsssize);
+		lputl(rnd(segdata.filelen, 4096));
+		lputl(segdata.len - segdata.filelen);
 		lputl(symsize);			/* nsyms */
 		lputl(entryvalue());		/* va of entry */
 		lputl(0L);
@@ -650,41 +456,8 @@ asmb(void)
 			phsh(ph, sh);
 		}
 
-		ph = newElfPhdr();
-		ph->type = PT_LOAD;
-		ph->flags = PF_X+PF_R;
-		ph->vaddr = va;
-		ph->paddr = va;
-		ph->off = fo;
-		ph->filesz = w;
-		ph->memsz = w;
-		ph->align = INITRND;
-
-		fo = rnd(fo+w, INITRND);
-		va = rnd(va+w, INITRND);
-		w = datsize;
-
-		ph = newElfPhdr();
-		ph->type = PT_LOAD;
-		ph->flags = PF_W+PF_R;
-		ph->off = fo;
-		ph->vaddr = va;
-		ph->paddr = va;
-		ph->filesz = w;
-		ph->memsz = w+bsssize;
-		ph->align = INITRND;
-
-		if(!debug['s']) {
-			ph = newElfPhdr();
-			ph->type = PT_LOAD;
-			ph->flags = PF_R;
-			ph->off = symo;
-			ph->vaddr = symdatva;
-			ph->paddr = symdatva;
-			ph->filesz = rnd(8+symsize+lcsize, INITRND);
-			ph->memsz = rnd(8+symsize+lcsize, INITRND);
-			ph->align = INITRND;
-		}
+		elfphload(&segtext);
+		elfphload(&segdata);
 
 		/* Dynamic linking sections */
 		if (!debug['d']) {	/* -d suppresses dynamic loader format */
@@ -766,81 +539,23 @@ asmb(void)
 		ph->flags = PF_W+PF_R;
 		ph->align = 4;
 
-		fo = ELFRESERVE;
-		va = startva + fo;
-		w = textsize;
-
-		/*
-		 * The alignments are bigger than they really need
-		 * to be here, but they are necessary to keep the
-		 * arm strip from moving everything around.
-		 */
-
-		sh = newElfShdr(elfstr[ElfStrText]);
-		sh->type = SHT_PROGBITS;
-		sh->flags = SHF_ALLOC+SHF_EXECINSTR;
-		sh->addr = va;
-		sh->off = fo;
-		sh->size = w;
-		sh->addralign = ELFRESERVE;
-
-		fo = rnd(fo+w, INITRND);
-		va = rnd(va+w, INITRND);
-		w = datsize;
-
-		sh = newElfShdr(elfstr[ElfStrData]);
-		sh->type = SHT_PROGBITS;
-		sh->flags = SHF_WRITE+SHF_ALLOC;
-		sh->addr = va + elfdatsize;
-		sh->off = fo + elfdatsize;
-		sh->size = w - elfdatsize;
-		sh->addralign = INITRND;
-
-		fo += w;
-		va += w;
-		w = bsssize;
-
-		sh = newElfShdr(elfstr[ElfStrBss]);
-		sh->type = SHT_NOBITS;
-		sh->flags = SHF_WRITE+SHF_ALLOC;
-		sh->addr = va;
-		sh->off = fo;
-		sh->size = w;
-		sh->addralign = 4;
+		for(sect=segtext.sect; sect!=nil; sect=sect->next)
+			elfshbits(sect);
+		for(sect=segdata.sect; sect!=nil; sect=sect->next)
+			elfshbits(sect);
 
 		if (!debug['s']) {
-			fo = symo;
-			w = 8;
-
 			sh = newElfShdr(elfstr[ElfStrGosymtab]);
 			sh->type = SHT_PROGBITS;
 			sh->flags = SHF_ALLOC;
-			sh->off = fo;
-			sh->size = w;
-			sh->addralign = INITRND;
-			sh->addr = symdatva;
-
-			fo += w;
-			w = symsize;
-
-			sh = newElfShdr(elfstr[ElfStrGosymtab]);
-			sh->type = SHT_PROGBITS;
-			sh->flags = SHF_ALLOC;
-			sh->off = fo;
-			sh->size = w;
 			sh->addralign = 1;
-			sh->addr = symdatva + 8;
-
-			fo += w;
-			w = lcsize;
+			shsym(sh, lookup("symtab", 0));
 
 			sh = newElfShdr(elfstr[ElfStrGopclntab]);
 			sh->type = SHT_PROGBITS;
 			sh->flags = SHF_ALLOC;
-			sh->off = fo;
-			sh->size = w;
 			sh->addralign = 1;
-			sh->addr = symdatva + 8 + lcsize;
+			shsym(sh, lookup("pclntab", 0));
 		}
 
 		sh = newElfShstrtab(elfstr[ElfStrShstrtab]);
@@ -879,27 +594,16 @@ asmb(void)
 	}
 	cflush();
 	if(debug['c']){
-		print("textsize=%ld\n", textsize);
-		print("datsize=%ld\n", datsize);
-		print("bsssize=%ld\n", bsssize);
-		print("symsize=%ld\n", symsize);
-		print("lcsize=%ld\n", lcsize);
-		print("total=%ld\n", textsize+datsize+bsssize+symsize+lcsize);
+		print("textsize=%d\n", textsize);
+		print("datsize=%d\n", segdata.filelen);
+		print("bsssize=%d\n", segdata.len - segdata.filelen);
+		print("symsize=%d\n", symsize);
+		print("lcsize=%d\n", lcsize);
+		print("total=%d\n", textsize+segdata.len+symsize+lcsize);
 	}
 }
 
 void
-strnput(char *s, int n)
-{
-	for(; *s; s++){
-		cput(*s);
-		n--;
-	}
-	for(; n > 0; n--)
-		cput(0);
-}
-
-void
 cput(int c)
 {
 	cbp[0] = c;
@@ -987,7 +691,7 @@ cflush(void)
 	/* no bug if cbc < 0 since obuf(cbuf) followed by ibuf in buf! */
 	n = sizeof(buf.cbuf) - cbc;
 	if(n)
-		write(cout, buf.cbuf, n);
+		ewrite(cout, buf.cbuf, n);
 	cbp = buf.cbuf;
 	cbc = sizeof(buf.cbuf);
 }
@@ -996,223 +700,16 @@ void
 nopstat(char *f, Count *c)
 {
 	if(c->outof)
-	Bprint(&bso, "%s delay %ld/%ld (%.2f)\n", f,
+	Bprint(&bso, "%s delay %d/%d (%.2f)\n", f,
 		c->outof - c->count, c->outof,
 		(double)(c->outof - c->count)/c->outof);
 }
 
-void
-asmsym(void)
-{
-	Prog *p;
-	Auto *a;
-	Sym *s;
-	int h;
-
-	s = lookup("etext", 0);
-	if(s->type == STEXT)
-		putsymb(s->name, 'T', s->value, s->version);
-
-	for(h=0; h<NHASH; h++)
-		for(s=hash[h]; s!=S; s=s->link)
-			switch(s->type) {
-			case SCONST:
-				putsymb(s->name, 'D', s->value, s->version);
-				continue;
-
-			case SDATA:
-			case SELFDATA:
-				putsymb(s->name, 'D', s->value+INITDAT, s->version);
-				continue;
-
-			case SBSS:
-				putsymb(s->name, 'B', s->value+INITDAT, s->version);
-				continue;
-
-			case SFIXED:
-				putsymb(s->name, 'B', s->value, s->version);
-				continue;
-
-			case SSTRING:
-				putsymb(s->name, 'T', s->value, s->version);
-				continue;
-
-			case SFILE:
-				putsymb(s->name, 'f', s->value, s->version);
-				continue;
-			}
-
-	for(p=textp; p!=P; p=p->cond) {
-		s = p->from.sym;
-		if(s->type != STEXT && s->type != SLEAF)
-			continue;
-
-		/* filenames first */
-		for(a=p->to.autom; a; a=a->link)
-			if(a->type == D_FILE)
-				putsymb(a->asym->name, 'z', a->aoffset, 0);
-			else
-			if(a->type == D_FILE1)
-				putsymb(a->asym->name, 'Z', a->aoffset, 0);
-
-		if(!s->reachable)
-			continue;
-
-		if(s->type == STEXT)
-			putsymb(s->name, 'T', s->value, s->version);
-		else
-			putsymb(s->name, 'L', s->value, s->version);
-
-		/* frame, auto and param after */
-		putsymb(".frame", 'm', p->to.offset+4, 0);
-		for(a=p->to.autom; a; a=a->link)
-			if(a->type == D_AUTO)
-				putsymb(a->asym->name, 'a', -a->aoffset, 0);
-			else
-			if(a->type == D_PARAM)
-				putsymb(a->asym->name, 'p', a->aoffset, 0);
-	}
-	if(debug['v'] || debug['n'])
-		Bprint(&bso, "symsize = %lud\n", symsize);
-	Bflush(&bso);
-}
-
-void
-putsymb(char *s, int t, int32 v, int ver)
-{
-	int i, f;
-
-	if(t == 'f')
-		s++;
-	lput(v);
-	if(ver)
-		t += 'a' - 'A';
-	cput(t+0x80);			/* 0x80 is variable length */
-
-	if(t == 'Z' || t == 'z') {
-		cput(s[0]);
-		for(i=1; s[i] != 0 || s[i+1] != 0; i += 2) {
-			cput(s[i]);
-			cput(s[i+1]);
-		}
-		cput(0);
-		cput(0);
-		i++;
-	}
-	else {
-		for(i=0; s[i]; i++)
-			cput(s[i]);
-		cput(0);
-	}
-	// TODO(rsc): handle go parameter
-	lput(0);
-
-	symsize += 4 + 1 + i + 1 + 4;
-
-	if(debug['n']) {
-		if(t == 'z' || t == 'Z') {
-			Bprint(&bso, "%c %.8lux ", t, v);
-			for(i=1; s[i] != 0 || s[i+1] != 0; i+=2) {
-				f = ((s[i]&0xff) << 8) | (s[i+1]&0xff);
-				Bprint(&bso, "/%x", f);
-			}
-			Bprint(&bso, "\n");
-			return;
-		}
-		if(ver)
-			Bprint(&bso, "%c %.8lux %s<%d>\n", t, v, s, ver);
-		else
-			Bprint(&bso, "%c %.8lux %s\n", t, v, s);
-	}
-}
-
-#define	MINLC	4
-void
-asmlc(void)
-{
-	int32 oldpc, oldlc;
-	Prog *p;
-	int32 v, s;
-
-	oldpc = INITTEXT;
-	oldlc = 0;
-	for(p = firstp; p != P; p = p->link) {
-		setarch(p);
-		if(p->line == oldlc || p->as == ATEXT || p->as == ANOP) {
-			if(p->as == ATEXT)
-				curtext = p;
-			if(debug['L'])
-				Bprint(&bso, "%6lux %P\n",
-					p->pc, p);
-			continue;
-		}
-		if(debug['L'])
-			Bprint(&bso, "\t\t%6ld", lcsize);
-		v = (p->pc - oldpc) / MINLC;
-		while(v) {
-			s = 127;
-			if(v < 127)
-				s = v;
-			cput(s+128);	/* 129-255 +pc */
-			if(debug['L'])
-				Bprint(&bso, " pc+%ld*%d(%ld)", s, MINLC, s+128);
-			v -= s;
-			lcsize++;
-		}
-		s = p->line - oldlc;
-		oldlc = p->line;
-		oldpc = p->pc + MINLC;
-		if(s > 64 || s < -64) {
-			cput(0);	/* 0 vv +lc */
-			cput(s>>24);
-			cput(s>>16);
-			cput(s>>8);
-			cput(s);
-			if(debug['L']) {
-				if(s > 0)
-					Bprint(&bso, " lc+%ld(%d,%ld)\n",
-						s, 0, s);
-				else
-					Bprint(&bso, " lc%ld(%d,%ld)\n",
-						s, 0, s);
-				Bprint(&bso, "%6lux %P\n",
-					p->pc, p);
-			}
-			lcsize += 5;
-			continue;
-		}
-		if(s > 0) {
-			cput(0+s);	/* 1-64 +lc */
-			if(debug['L']) {
-				Bprint(&bso, " lc+%ld(%ld)\n", s, 0+s);
-				Bprint(&bso, "%6lux %P\n",
-					p->pc, p);
-			}
-		} else {
-			cput(64-s);	/* 65-128 -lc */
-			if(debug['L']) {
-				Bprint(&bso, " lc%ld(%ld)\n", s, 64-s);
-				Bprint(&bso, "%6lux %P\n",
-					p->pc, p);
-			}
-		}
-		lcsize++;
-	}
-	while(lcsize & 1) {
-		s = 129;
-		cput(s);
-		lcsize++;
-	}
-	if(debug['v'] || debug['L'])
-		Bprint(&bso, "lcsize = %ld\n", lcsize);
-	Bflush(&bso);
-}
-
 static void
 outt(int32 f, int32 l)
 {
 	if(debug['L'])
-		Bprint(&bso, "tmap: %lux-%lux\n", f, l);
+		Bprint(&bso, "tmap: %ux-%ux\n", f, l);
 	lput(f);
 	lput(l);
 }
@@ -1227,186 +724,46 @@ asmthumbmap(void)
 		return;
 	pc = 0;
 	lastt = -1;
-	for(p = firstp; p != P; p = p->link){
+	for(cursym = textp; cursym != nil; cursym = cursym->next) {
+		p = cursym->text;
 		pc = p->pc - INITTEXT;
-		if(p->as == ATEXT){
-			setarch(p);
-			if(thumb){
-				if(p->from.sym->foreign){	// 8 bytes of ARM first
-					if(lastt >= 0){
-						outt(lastt, pc-1);
-						lastt = -1;
-					}
-					pc += 8;
-				}
-				if(lastt < 0)
-					lastt = pc;
-			}
-			else{
-				if(p->from.sym->foreign){	// 4 bytes of THUMB first
-					if(lastt < 0)
-						lastt = pc;
-					pc += 4;
-				}
+		setarch(p);
+		if(thumb){
+			if(p->from.sym->foreign){	// 8 bytes of ARM first
 				if(lastt >= 0){
 					outt(lastt, pc-1);
 					lastt = -1;
 				}
+				pc += 8;
 			}
+			if(lastt < 0)
+				lastt = pc;
 		}
-	}
-	if(lastt >= 0)
-		outt(lastt, pc+1);
-}
-
-void
-datblk(int32 s, int32 n, int str)
-{
-	Sym *v;
-	Prog *p;
-	char *cast;
-	int32 a, l, fl, j, d;
-	int i, c;
-
-	memset(buf.dbuf, 0, n+100);
-	for(p = datap; p != P; p = p->link) {
-		if(str != (p->from.sym->type == SSTRING))
-			continue;
-		curp = p;
-		a = p->from.sym->value + p->from.offset;
-		l = a - s;
-		c = p->reg;
-		i = 0;
-		if(l < 0) {
-			if(l+c <= 0)
-				continue;
-			while(l < 0) {
-				l++;
-				i++;
-			}
-		}
-		if(l >= n)
-			continue;
-		if(p->as != AINIT && p->as != ADYNT) {
-			for(j=l+(c-i)-1; j>=l; j--)
-				if(buf.dbuf[j]) {
-					print("%P\n", p);
-					diag("multiple initialization");
-					break;
-				}
-		}
-		switch(p->to.type) {
-		default:
-			diag("unknown mode in initialization%P", p);
-			break;
-
-		case D_FCONST:
-			switch(c) {
-			default:
-			case 4:
-				fl = ieeedtof(p->to.ieee);
-				cast = (char*)&fl;
-				for(; i<c; i++) {
-					buf.dbuf[l] = cast[fnuxi4[i]];
-					l++;
-				}
-				break;
-			case 8:
-				cast = (char*)p->to.ieee;
-				for(; i<c; i++) {
-					buf.dbuf[l] = cast[fnuxi8[i]];
-					l++;
-				}
-				break;
-			}
-			break;
-
-		case D_SCONST:
-			for(; i<c; i++) {
-				buf.dbuf[l] = p->to.sval[i];
-				l++;
-			}
-			break;
-
-		case D_CONST:
-			d = p->to.offset;
-			v = p->to.sym;
-			if(v) {
-				switch(v->type) {
-				case SUNDEF:
-					ckoff(v, d);
-					d += v->value;
-					break;
-				case STEXT:
-				case SLEAF:
-					d += v->value;
-#ifdef CALLEEBX
-					d += fnpinc(v);
-#else
-					if(v->thumb)
-						d++;		// T bit
-#endif
-					break;
-				case SSTRING:
-					d += v->value;
-					break;
-				case SDATA:
-				case SBSS:
-					if(p->to.type == D_SIZE)
-						d += v->size;
-					else
-						d += v->value + INITDAT;
-					break;
-				}
-				if(dlm)
-					dynreloc(v, a+INITDAT, 1);
-			}
-			cast = (char*)&d;
-			switch(c) {
-			default:
-				diag("bad nuxi %d %d%P", c, i, curp);
-				break;
-			case 1:
-				for(; i<c; i++) {
-					buf.dbuf[l] = cast[inuxi1[i]];
-					l++;
-				}
-				break;
-			case 2:
-				for(; i<c; i++) {
-					buf.dbuf[l] = cast[inuxi2[i]];
-					l++;
-				}
-				break;
-			case 4:
-				for(; i<c; i++) {
-					buf.dbuf[l] = cast[inuxi4[i]];
-					l++;
-				}
-				break;
-			}
-			break;
-
-		case D_SBIG:
-			if(debug['a'] && i == 0) {
-				Bprint(&bso, "\t%P\n", curp);
+		else{
+			if(p->from.sym->foreign){	// 4 bytes of THUMB first
+				if(lastt < 0)
+					lastt = pc;
+				pc += 4;
 			}
-			for(; i<c; i++) {
-				buf.dbuf[l] = p->to.sbig[i];
-				l++;
+			if(lastt >= 0){
+				outt(lastt, pc-1);
+				lastt = -1;
 			}
-			break;
 		}
+		if(cursym->next == nil)
+			for(; p != P; p = p->link)
+				pc = p->pc = INITTEXT;
 	}
-	write(cout, buf.dbuf, n);
+	if(lastt >= 0)
+		outt(lastt, pc+1);
 }
 
 void
-asmout(Prog *p, Optab *o)
+asmout(Prog *p, Optab *o, int32 *out)
 {
 	int32 o1, o2, o3, o4, o5, o6, v;
 	int r, rf, rt, rt2;
-	Sym *s;
+	Reloc *rel;
 
 PP = p;
 	o1 = 0;
@@ -1416,7 +773,7 @@ PP = p;
 	o5 = 0;
 	o6 = 0;
 	armsize += o->size;
-if(debug['P']) print("%ulx: %P	type %d\n", (uint32)(p->pc), p, o->type);
+if(debug['P']) print("%ux: %P	type %d\n", (uint32)(p->pc), p, o->type);
 	switch(o->type) {
 	default:
 		diag("unknown asm %d", o->type);
@@ -1424,7 +781,7 @@ if(debug['P']) print("%ulx: %P	type %d\n", (uint32)(p->pc), p, o->type);
 		break;
 
 	case 0:		/* pseudo ops */
-if(debug['G']) print("%ulx: %s: arm %d %d %d %d\n", (uint32)(p->pc), p->from.sym->name, p->from.sym->thumb, p->from.sym->foreign, p->from.sym->fnptr, p->from.sym->used);
+if(debug['G']) print("%ux: %s: arm %d %d %d\n", (uint32)(p->pc), p->from.sym->name, p->from.sym->thumb, p->from.sym->foreign, p->from.sym->fnptr);
 		break;
 
 	case 1:		/* op R,[R],R */
@@ -1485,14 +842,7 @@ if(debug['G']) print("%ulx: %s: arm %d %d %d %d\n", (uint32)(p->pc), p->from.sym
 
 	case 5:		/* bra s */
 		v = -8;
-		if(p->cond == UP) {
-			s = p->to.sym;
-			if(s->type != SUNDEF)
-				diag("bad branch sym type");
-			v = (uint32)s->value >> (Roffset-2);
-			dynreloc(s, p->pc, 0);
-		}
-		else if(p->cond != P)
+		if(p->cond != P)
 			v = (p->cond->pc - pc) - 8;
 #ifdef CALLEEBX
 		if(p->as == ABL)
@@ -1553,18 +903,17 @@ if(debug['G']) print("%ulx: %s: arm %d %d %d %d\n", (uint32)(p->pc), p->from.sym
 		break;
 
 	case 11:	/* word */
-		switch(aclass(&p->to)) {
-		case C_LCON:
-			if(!dlm)
-				break;
-			if(p->to.name != D_EXTERN && p->to.name != D_STATIC)
-				break;
-		case C_ADDR:
-			if(p->to.sym->type == SUNDEF)
-				ckoff(p->to.sym, p->to.offset);
-			dynreloc(p->to.sym, p->pc, 1);
-		}
+		aclass(&p->to);
 		o1 = instoffset;
+		if(p->to.sym != S) {
+			rel = addrel(cursym);
+			rel->off = pc - cursym->value;
+			rel->siz = 4;
+			rel->type = D_ADDR;
+			rel->sym = p->to.sym;
+			rel->add = p->to.offset;
+			o1 = 0;
+		}
 		break;
 
 	case 12:	/* movw $lcon, reg */
@@ -1890,38 +1239,15 @@ if(debug['G']) print("%ulx: %s: arm %d %d %d %d\n", (uint32)(p->pc), p->from.sym
 
 	case 54:	/* floating point arith */
 		o1 = oprrr(p->as, p->scond);
-		if(p->from.type == D_FCONST) {
-			rf = chipfloat(p->from.ieee);
-			if(rf < 0){
-				diag("invalid floating-point immediate\n%P", p);
-				rf = 0;
-			}
-			rf |= (1<<3);
-		} else
-			rf = p->from.reg;
+		rf = p->from.reg;
 		rt = p->to.reg;
 		r = p->reg;
-		if(p->to.type == D_NONE)
-			rt = 0;	/* CMP[FD] */
-		else if(o1 & (1<<15))
-			r = 0;	/* monadic */
-		else if(r == NREG)
+		if(r == NREG) {
 			r = rt;
-		o1 |= rf | (r<<16) | (rt<<12);
-		break;
-
-	case 55:	/* floating point fix and float */
-		o1 = oprrr(p->as, p->scond);
-		rf = p->from.reg;
-		rt = p->to.reg;
-		if(p->to.type == D_NONE){
-			rt = 0;
-			diag("to.type==D_NONE (asm/fp)");
+			if(p->as == AMOVF || p->as == AMOVD)
+				r = 0;
 		}
-		if(p->from.type == D_REG)
-			o1 |= (rf<<12) | (rt<<16);
-		else
-			o1 |= rf | (rt<<12);
+		o1 |= rf | (r<<16) | (rt<<12);
 		break;
 
 	case 56:	/* move to FP[CS]R */
@@ -1983,11 +1309,8 @@ if(debug['G']) print("%ulx: %s: arm %d %d %d %d\n", (uint32)(p->pc), p->from.sym
 		break;
 
 	case 63:	/* bcase */
-		if(p->cond != P) {
+		if(p->cond != P)
 			o1 = p->cond->pc;
-			if(dlm)
-				dynreloc(S, p->pc, 1);
-		}
 		break;
 
 	/* reloc ops */
@@ -2114,7 +1437,7 @@ if(debug['G']) print("%ulx: %s: arm %d %d %d %d\n", (uint32)(p->pc), p->from.sym
 		if(p->to.sym->thumb)
 			v |= 1;	// T bit
 		o1 = olr(8, REGPC, REGTMP, p->scond&C_SCOND);	// mov 8(PC), Rtmp
-		o2 = 	oprrr(AADD, p->scond) | immrot(8) | (REGPC<<16) | (REGLINK<<12);	// add 8,PC, LR
+		o2 = oprrr(AADD, p->scond) | immrot(8) | (REGPC<<16) | (REGLINK<<12);	// add 8,PC, LR
 		o3 = ((p->scond&C_SCOND)<<28) | (0x12fff<<8) | (1<<4) | REGTMP;		// bx Rtmp
 		o4 = opbra(AB, 14);	// B over o6
 		o5 = v;
@@ -2132,7 +1455,7 @@ if(debug['G']) print("%ulx: %s: arm %d %d %d %d\n", (uint32)(p->pc), p->from.sym
 		o1 |= immrot(instoffset);
 		o1 |= p->to.reg << 16;
 		o1 |= REGTMP << 12;
-		o2 = 	oprrr(AADD, p->scond) | immrot(0) | (REGPC<<16) | (REGLINK<<12);	// mov PC, LR
+		o2 = oprrr(AADD, p->scond) | immrot(0) | (REGPC<<16) | (REGLINK<<12);	// mov PC, LR
 		o3 = ((p->scond&C_SCOND)<<28) | (0x12fff<<8) | (1<<4) | REGTMP;		// BX Rtmp
 		break;
 	case 76:	/* bx O(R) when returning from fn*/
@@ -2164,35 +1487,114 @@ if(debug['G']) print("%ulx: %s: arm %d %d %d %d\n", (uint32)(p->pc), p->from.sym
 		o1 |= p->to.reg << 12;
 		o1 |= (p->scond & C_SCOND) << 28;
 		break;
+	case 80:	/* fmov zfcon,freg */
+		if((p->scond & C_SCOND) != C_SCOND_NONE)
+			diag("floating point cannot be conditional");	// cant happen
+		o1 = 0xf3000110;	// EOR 64
+
+		// always clears the double float register
+		r = p->to.reg;
+		o1 |= r << 0;
+		o1 |= r << 12;
+		o1 |= r << 16;
+		break;
+	case 81:	/* fmov sfcon,freg */
+		o1 = 0x0eb00a00;		// VMOV imm 32
+		if(p->as == AMOVD)
+			o1 = 0xeeb00b00;	// VMOV imm 64
+		o1 |= (p->scond & C_SCOND) << 28;
+		o1 |= p->to.reg << 12;
+		v = chipfloat(&p->from.ieee);
+		o1 |= (v&0xf) << 0;
+		o1 |= (v&0xf0) << 12;
+		break;
+	case 82:	/* fcmp freg,freg, */
+		o1 = oprrr(p->as, p->scond);
+		o1 |= (p->reg<<12) | (p->from.reg<<0);
+		o2 = 0x0ef1fa10;	// VMRS R15
+		o2 |= (p->scond & C_SCOND) << 28;
+		break;
+	case 83:	/* fcmp freg,, */
+		o1 = oprrr(p->as, p->scond);
+		o1 |= (p->from.reg<<12) | (1<<16);
+		o2 = 0x0ef1fa10;	// VMRS R15
+		o2 |= (p->scond & C_SCOND) << 28;
+		break;
+	case 84:	/* movfw freg,freg - truncate float-to-fix */
+		o1 = oprrr(p->as, p->scond);
+		o1 |= (p->from.reg<<0);
+		o1 |= (p->to.reg<<12);
+		break;
+	case 85:	/* movwf freg,freg - fix-to-float */
+		o1 = oprrr(p->as, p->scond);
+		o1 |= (p->from.reg<<0);
+		o1 |= (p->to.reg<<12);
+		break;
+	case 86:	/* movfw freg,reg - truncate float-to-fix */
+		// macro for movfw freg,FTMP; movw FTMP,reg
+		o1 = oprrr(p->as, p->scond);
+		o1 |= (p->from.reg<<0);
+		o1 |= (FREGTMP<<12);
+		o2 = oprrr(AMOVFW+AEND, p->scond);
+		o2 |= (FREGTMP<<16);
+		o2 |= (p->to.reg<<12);
+		break;
+	case 87:	/* movwf reg,freg - fix-to-float */
+		// macro for movw reg,FTMP; movwf FTMP,freg
+		o1 = oprrr(AMOVWF+AEND, p->scond);
+		o1 |= (p->from.reg<<12);
+		o1 |= (FREGTMP<<16);
+		o2 = oprrr(p->as, p->scond);
+		o2 |= (FREGTMP<<0);
+		o2 |= (p->to.reg<<12);
+		break;
+	case 88:	/* movw reg,freg  */
+		o1 = oprrr(AMOVWF+AEND, p->scond);
+		o1 |= (p->from.reg<<12);
+		o1 |= (p->to.reg<<16);
+		break;
+	case 89:	/* movw freg,reg  */
+		o1 = oprrr(AMOVFW+AEND, p->scond);
+		o1 |= (p->from.reg<<16);
+		o1 |= (p->to.reg<<12);
+		break;
 	}
+	
+	out[0] = o1;
+	out[1] = o2;
+	out[2] = o3;
+	out[3] = o4;
+	out[4] = o5;
+	out[5] = o6;
+	return;
 
 	v = p->pc;
 	switch(o->size) {
 	default:
 		if(debug['a'])
-			Bprint(&bso, " %.8lux:\t\t%P\n", v, p);
+			Bprint(&bso, " %.8ux:\t\t%P\n", v, p);
 		break;
 	case 4:
 		if(debug['a'])
-			Bprint(&bso, " %.8lux: %.8lux\t%P\n", v, o1, p);
+			Bprint(&bso, " %.8ux: %.8ux\t%P\n", v, o1, p);
 		lputl(o1);
 		break;
 	case 8:
 		if(debug['a'])
-			Bprint(&bso, " %.8lux: %.8lux %.8lux%P\n", v, o1, o2, p);
+			Bprint(&bso, " %.8ux: %.8ux %.8ux%P\n", v, o1, o2, p);
 		lputl(o1);
 		lputl(o2);
 		break;
 	case 12:
 		if(debug['a'])
-			Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux%P\n", v, o1, o2, o3, p);
+			Bprint(&bso, " %.8ux: %.8ux %.8ux %.8ux%P\n", v, o1, o2, o3, p);
 		lputl(o1);
 		lputl(o2);
 		lputl(o3);
 		break;
 	case 16:
 		if(debug['a'])
-			Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux %.8lux%P\n",
+			Bprint(&bso, " %.8ux: %.8ux %.8ux %.8ux %.8ux%P\n",
 				v, o1, o2, o3, o4, p);
 		lputl(o1);
 		lputl(o2);
@@ -2201,7 +1603,7 @@ if(debug['G']) print("%ulx: %s: arm %d %d %d %d\n", (uint32)(p->pc), p->from.sym
 		break;
 	case 20:
 		if(debug['a'])
-			Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux %.8lux %.8lux%P\n",
+			Bprint(&bso, " %.8ux: %.8ux %.8ux %.8ux %.8ux %.8ux%P\n",
 				v, o1, o2, o3, o4, o5, p);
 		lputl(o1);
 		lputl(o2);
@@ -2211,7 +1613,7 @@ if(debug['G']) print("%ulx: %s: arm %d %d %d %d\n", (uint32)(p->pc), p->from.sym
 		break;
 	case 24:
 		if(debug['a'])
-			Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux %.8lux %.8lux %.8lux%P\n",
+			Bprint(&bso, " %.8ux: %.8ux %.8ux %.8ux %.8ux %.8ux %.8ux%P\n",
 				v, o1, o2, o3, o4, o5, o6, p);
 		lputl(o1);
 		lputl(o2);
@@ -2262,26 +1664,51 @@ oprrr(int a, int sc)
 	case ASRA:	return o | (0xd<<21) | (2<<5);
 	case ASWI:	return o | (0xf<<24);
 
-	case AADDD:	return o | (0xe<<24) | (0x0<<20) | (1<<8) | (1<<7);
-	case AADDF:	return o | (0xe<<24) | (0x0<<20) | (1<<8);
-	case AMULD:	return o | (0xe<<24) | (0x1<<20) | (1<<8) | (1<<7);
-	case AMULF:	return o | (0xe<<24) | (0x1<<20) | (1<<8);
-	case ASUBD:	return o | (0xe<<24) | (0x2<<20) | (1<<8) | (1<<7);
-	case ASUBF:	return o | (0xe<<24) | (0x2<<20) | (1<<8);
-	case ADIVD:	return o | (0xe<<24) | (0x4<<20) | (1<<8) | (1<<7);
-	case ADIVF:	return o | (0xe<<24) | (0x4<<20) | (1<<8);
-	case ACMPD:
-	case ACMPF:	return o | (0xe<<24) | (0x9<<20) | (0xF<<12) | (1<<8) | (1<<4);	/* arguably, ACMPF should expand to RNDF, CMPD */
-
-	case AMOVF:
-	case AMOVDF:	return o | (0xe<<24) | (0x0<<20) | (1<<15) | (1<<8);
-	case AMOVD:
-	case AMOVFD:	return o | (0xe<<24) | (0x0<<20) | (1<<15) | (1<<8) | (1<<7);
-
-	case AMOVWF:	return o | (0xe<<24) | (0<<20) | (1<<8) | (1<<4);
-	case AMOVWD:	return o | (0xe<<24) | (0<<20) | (1<<8) | (1<<4) | (1<<7);
-	case AMOVFW:	return o | (0xe<<24) | (1<<20) | (1<<8) | (1<<4);
-	case AMOVDW:	return o | (0xe<<24) | (1<<20) | (1<<8) | (1<<4) | (1<<7);
+	case AADDD:	return o | (0xe<<24) | (0x3<<20) | (0xb<<8) | (0<<4);
+	case AADDF:	return o | (0xe<<24) | (0x3<<20) | (0xa<<8) | (0<<4);
+	case ASUBD:	return o | (0xe<<24) | (0x3<<20) | (0xb<<8) | (4<<4);
+	case ASUBF:	return o | (0xe<<24) | (0x3<<20) | (0xa<<8) | (4<<4);
+	case AMULD:	return o | (0xe<<24) | (0x2<<20) | (0xb<<8) | (0<<4);
+	case AMULF:	return o | (0xe<<24) | (0x2<<20) | (0xa<<8) | (0<<4);
+	case ADIVD:	return o | (0xe<<24) | (0x8<<20) | (0xb<<8) | (0<<4);
+	case ADIVF:	return o | (0xe<<24) | (0x8<<20) | (0xa<<8) | (0<<4);
+	case ACMPD:	return o | (0xe<<24) | (0xb<<20) | (4<<16) | (0xb<<8) | (0xc<<4);
+	case ACMPF:	return o | (0xe<<24) | (0xb<<20) | (4<<16) | (0xa<<8) | (0xc<<4);
+
+	case AMOVF:	return o | (0xe<<24) | (0xb<<20) | (0<<16) | (0xa<<8) | (4<<4);
+	case AMOVD:	return o | (0xe<<24) | (0xb<<20) | (0<<16) | (0xb<<8) | (4<<4);
+
+	case AMOVDF:	return o | (0xe<<24) | (0xb<<20) | (7<<16) | (0xa<<8) | (0xc<<4) |
+			(1<<8);	// dtof
+	case AMOVFD:	return o | (0xe<<24) | (0xb<<20) | (7<<16) | (0xa<<8) | (0xc<<4) |
+			(0<<8);	// dtof
+
+	case AMOVWF:
+			if((sc & C_UBIT) == 0)
+				o |= 1<<7;	/* signed */
+			return o | (0xe<<24) | (0xb<<20) | (8<<16) | (0xa<<8) | (4<<4) |
+				(0<<18) | (0<<8);	// toint, double
+	case AMOVWD:
+			if((sc & C_UBIT) == 0)
+				o |= 1<<7;	/* signed */
+			return o | (0xe<<24) | (0xb<<20) | (8<<16) | (0xa<<8) | (4<<4) |
+				(0<<18) | (1<<8);	// toint, double
+
+	case AMOVFW:
+			if((sc & C_UBIT) == 0)
+				o |= 1<<16;	/* signed */
+			return o | (0xe<<24) | (0xb<<20) | (8<<16) | (0xa<<8) | (4<<4) |
+				(1<<18) | (0<<8) | (1<<7);	// toint, double, trunc
+	case AMOVDW:
+			if((sc & C_UBIT) == 0)
+				o |= 1<<16;	/* signed */
+			return o | (0xe<<24) | (0xb<<20) | (8<<16) | (0xa<<8) | (4<<4) |
+				(1<<18) | (1<<8) | (1<<7);	// toint, double, trunc
+
+	case AMOVWF+AEND:	// copy WtoF
+		return o | (0xe<<24) | (0x0<<20) | (0xb<<8) | (1<<4);
+	case AMOVFW+AEND:	// copy FtoW
+		return o | (0xe<<24) | (0x1<<20) | (0xb<<8) | (1<<4);
 	}
 	diag("bad rrr %d", a);
 	prasm(curp);
@@ -2337,12 +1764,13 @@ olr(int32 v, int b, int r, int sc)
 		o |= 1 << 23;
 	if(sc & C_WBIT)
 		o |= 1 << 21;
-	o |= (0x1<<26) | (1<<20);
+	o |= (1<<26) | (1<<20);
 	if(v < 0) {
+		if(sc & C_UBIT) diag(".U on neg offset");
 		v = -v;
 		o ^= 1 << 23;
 	}
-	if(v >= (1<<12))
+	if(v >= (1<<12) || v < 0)
 		diag("literal span too large: %d (R%d)\n%P", v, b, PP);
 	o |= v;
 	o |= b << 16;
@@ -2367,7 +1795,7 @@ olhr(int32 v, int b, int r, int sc)
 		v = -v;
 		o ^= 1 << 23;
 	}
-	if(v >= (1<<8))
+	if(v >= (1<<8) || v < 0)
 		diag("literal span too large: %d (R%d)\n%P", v, b, PP);
 	o |= (v&0xf)|((v>>4)<<8)|(1<<22);
 	o |= b << 16;
@@ -2434,25 +1862,25 @@ ofsr(int a, int r, int32 v, int b, int sc, Prog *p)
 		o |= 1 << 24;
 	if(sc & C_WBIT)
 		o |= 1 << 21;
-	o |= (6<<25) | (1<<24) | (1<<23);
+	o |= (6<<25) | (1<<24) | (1<<23) | (10<<8);
 	if(v < 0) {
 		v = -v;
 		o ^= 1 << 23;
 	}
 	if(v & 3)
 		diag("odd offset for floating point op: %d\n%P", v, p);
-	else if(v >= (1<<10))
+	else
+	if(v >= (1<<10) || v < 0)
 		diag("literal span too large: %d\n%P", v, p);
 	o |= (v>>2) & 0xFF;
 	o |= b << 16;
 	o |= r << 12;
-	o |= 1 << 8;
 
 	switch(a) {
 	default:
 		diag("bad fst %A", a);
 	case AMOVD:
-		o |= 1<<15;
+		o |= 1 << 8;
 	case AMOVF:
 		break;
 	}
@@ -2481,28 +1909,104 @@ omvl(Prog *p, Adr *a, int dr)
 	return o1;
 }
 
-static Ieee chipfloats[] = {
-	{0x00000000, 0x00000000}, /* 0 */
-	{0x00000000, 0x3ff00000}, /* 1 */
-	{0x00000000, 0x40000000}, /* 2 */
-	{0x00000000, 0x40080000}, /* 3 */
-	{0x00000000, 0x40100000}, /* 4 */
-	{0x00000000, 0x40140000}, /* 5 */
-	{0x00000000, 0x3fe00000}, /* .5 */
-	{0x00000000, 0x40240000}, /* 10 */
-};
+int
+chipzero(Ieee *e)
+{
+	if(e->l != 0 || e->h != 0)
+		return -1;
+	return 0;
+}
 
 int
 chipfloat(Ieee *e)
 {
-	Ieee *p;
 	int n;
+	ulong h;
 
-	for(n = sizeof(chipfloats)/sizeof(chipfloats[0]); --n >= 0;){
-		p = &chipfloats[n];
-		if(p->l == e->l && p->h == e->h)
-			return n;
-	}
+	if(e->l != 0 || (e->h&0xffff) != 0)
+		goto no;
+	h = e->h & 0x7fc00000;
+	if(h != 0x40000000 && h != 0x3fc00000)
+		goto no;
+	n = 0;
+
+	// sign bit (a)
+	if(e->h & 0x80000000)
+		n |= 1<<7;
+
+	// exp sign bit (b)
+	if(h == 0x3fc00000)
+		n |= 1<<6;
+
+	// rest of exp and mantissa (cd-efgh)
+	n |= (e->h >> 16) & 0x3f;
+
+//print("match %.8lux %.8lux %d\n", e->l, e->h, n);
+	return n;
+
+no:
 	return -1;
 }
 
+
+void
+genasmsym(void (*put)(Sym*, char*, int, vlong, vlong, int, Sym*))
+{
+	Auto *a;
+	Sym *s;
+	int h;
+
+	s = lookup("etext", 0);
+	if(s->type == STEXT)
+		put(s, s->name, 'T', s->value, s->size, s->version, 0);
+
+	for(h=0; h<NHASH; h++) {
+		for(s=hash[h]; s!=S; s=s->hash) {
+			switch(s->type) {
+			case SCONST:
+			case SRODATA:
+			case SDATA:
+			case SELFDATA:
+				if(!s->reachable)
+					continue;
+				put(s, s->name, 'D', s->value, s->size, s->version, s->gotype);
+				continue;
+
+			case SBSS:
+				if(!s->reachable)
+					continue;
+				put(s, s->name, 'B', s->value, s->size, s->version, s->gotype);
+				continue;
+
+			case SFILE:
+				put(nil, s->name, 'f', s->value, 0, s->version, 0);
+				continue;
+			}
+		}
+	}
+
+	for(s = textp; s != nil; s = s->next) {
+		/* filenames first */
+		for(a=s->autom; a; a=a->link)
+			if(a->type == D_FILE)
+				put(nil, a->asym->name, 'z', a->aoffset, 0, 0, 0);
+			else
+			if(a->type == D_FILE1)
+				put(nil, a->asym->name, 'Z', a->aoffset, 0, 0, 0);
+
+		put(s, s->name, 'T', s->value, s->size, s->version, s->gotype);
+
+		/* frame, auto and param after */
+		put(nil, ".frame", 'm', s->text->to.offset+4, 0, 0, 0);
+
+		for(a=s->autom; a; a=a->link)
+			if(a->type == D_AUTO)
+				put(nil, a->asym->name, 'a', -a->aoffset, 0, 0, a->gotype);
+			else
+			if(a->type == D_PARAM)
+				put(nil, a->asym->name, 'p', a->aoffset, 0, 0, a->gotype);
+	}
+	if(debug['v'] || debug['n'])
+		Bprint(&bso, "symsize = %ud\n", symsize);
+	Bflush(&bso);
+}
diff --git a/src/cmd/5l/doc.go b/src/cmd/5l/doc.go
index b09995d71..6f7408116 100644
--- a/src/cmd/5l/doc.go
+++ b/src/cmd/5l/doc.go
@@ -20,8 +20,8 @@ Original options are listed in the link above.
 
 Options new in this version:
 
--L dir1,dir2,..
-	Search for libraries (package files) in the comma-separated list of directories.
+-L dir1 -L dir2
+	Search for libraries (package files) in dir1, dir2, etc.
 	The default is the single location $GOROOT/pkg/$GOOS_arm.
 -r dir1:dir2:...
 	Set the dynamic linker search path when using ELF.
diff --git a/src/cmd/5l/l.h b/src/cmd/5l/l.h
index c6659cfab..4e7ccea88 100644
--- a/src/cmd/5l/l.h
+++ b/src/cmd/5l/l.h
@@ -45,20 +45,21 @@ enum
 /* do not undefine this - code will be removed eventually */
 #define	CALLEEBX
 
+#define	dynptrsize	0
+
 typedef	struct	Adr	Adr;
 typedef	struct	Sym	Sym;
 typedef	struct	Autom	Auto;
 typedef	struct	Prog	Prog;
+typedef	struct	Reloc	Reloc;
 typedef	struct	Optab	Optab;
 typedef	struct	Oprang	Oprang;
 typedef	uchar	Opcross[32][2][32];
 typedef	struct	Count	Count;
-typedef	struct	Use	Use;
 
 #define	P		((Prog*)0)
 #define	S		((Sym*)0)
-#define	U		((Use*)0)
-#define	TNAME		(curtext&&curtext->from.sym?curtext->from.sym->name:noname)
+#define	TNAME		(cursym?cursym->name:noname)
 
 struct	Adr
 {
@@ -66,14 +67,10 @@ struct	Adr
 	{
 		int32	u0offset;
 		char*	u0sval;
-		Ieee*	u0ieee;
+		Ieee	u0ieee;
 		char*	u0sbig;
 	} u0;
-	union
-	{
-		Auto*	u1autom;
-		Sym*	u1sym;
-	} u1;
+	Sym*	sym;
 	char	type;
 	uchar	index; // not used on arm, required by ld/go.c
 	char	reg;
@@ -85,11 +82,18 @@ struct	Adr
 
 #define	offset	u0.u0offset
 #define	sval	u0.u0sval
+#define	scon	sval
 #define	ieee	u0.u0ieee
 #define	sbig	u0.u0sbig
 
-#define	autom	u1.u1autom
-#define	sym	u1.u1sym
+struct	Reloc
+{
+	int32	off;
+	uchar	siz;
+	int16	type;
+	int32	add;
+	Sym*	sym;
+};
 
 struct	Prog
 {
@@ -112,35 +116,51 @@ struct	Prog
 	uchar	reg;
 	uchar	align;
 };
+
 #define	regused	u0.u0regused
 #define	forwd	u0.u0forwd
+#define	datasize	reg
+#define	textflag	reg
 
 struct	Sym
 {
-	char	*name;
+	char*	name;
 	short	type;
 	short	version;
-	short	become;
-	short	frame;
-	uchar	subtype;
 	uchar	dupok;
 	uchar	reachable;
 	uchar	dynexport;
+	uchar	leaf;
+	int32	dynid;
+	int32	plt;
+	int32	got;
 	int32	value;
 	int32	sig;
 	int32	size;
-	uchar	used;
+	uchar	special;
 	uchar	thumb;	// thumb code
 	uchar	foreign;	// called by arm if thumb, by thumb if arm
 	uchar	fnptr;	// used as fn ptr
-	Use*		use;
-	Sym*	link;
-	Prog*	text;
-	Prog*	data;
+	Sym*	hash;	// in hash table
+	Sym*	next;	// in text or data list
+	Sym*	sub;	// in SSUB list
+	Sym*	outer;	// container of sub
 	Sym*	gotype;
 	char*	file;
 	char*	dynimpname;
 	char*	dynimplib;
+	
+	// STEXT
+	Auto*	autom;
+	Prog*	text;
+	
+	// SDATA, SBSS
+	uchar*	p;
+	int32	np;
+	int32	maxp;
+	Reloc*	r;
+	int32	nr;
+	int32	maxr;
 };
 
 #define SIGNINTERN	(1729*325*1729)
@@ -174,34 +194,24 @@ struct	Count
 	int32	count;
 	int32	outof;
 };
-struct	Use
-{
-	Prog*	p;	/* use */
-	Prog*	ct;	/* curtext */
-	Use*		link;
-};
 
 enum
 {
 	Sxxx,
-
+	
+	/* order here is order in output file */
 	STEXT		= 1,
+	SRODATA,
+	SELFDATA,
 	SDATA,
 	SBSS,
-	SDATA1,
+
 	SXREF,
-	SLEAF,
 	SFILE,
 	SCONST,
-	SSTRING,
-	SUNDEF,
-	SREMOVED,
+	SDYNIMPORT,
 
-	SIMPORT,
-	SEXPORT,
-	
-	SFIXED,
-	SELFDATA,
+	SSUB	= 1<<8,
 
 	LFROM		= 1<<0,
 	LTO		= 1<<1,
@@ -221,7 +231,9 @@ enum
 	C_SCON,		/* 0xffff */
 	C_BCON,		/* thumb */
 	C_LCON,
-	C_FCON,
+	C_ZFCON,
+	C_SFCON,
+	C_LFCON,
 	C_GCON,		/* thumb */
 
 	C_RACON,
@@ -229,9 +241,6 @@ enum
 	C_LACON,
 	C_GACON,	/* thumb */
 
-	C_RECON,
-	C_LECON,
-
 	C_SBRA,
 	C_LBRA,
 	C_GBRA,		/* thumb */
@@ -242,12 +251,6 @@ enum
 	C_SAUTO,	/* -0xfff to 0xfff */
 	C_LAUTO,
 
-	C_HEXT,
-	C_FEXT,
-	C_HFEXT,
-	C_SEXT,
-	C_LEXT,
-
 	C_HOREG,
 	C_FOREG,
 	C_HFOREG,
@@ -262,7 +265,7 @@ enum
 	C_HREG,
 	C_OFFPC,		/* thumb */
 
-	C_ADDR,		/* relocatable address */
+	C_ADDR,		/* reference to relocatable address */
 
 	C_GOK,
 
@@ -271,7 +274,6 @@ enum
 	LABEL		= 1<<1,
 	LEAF		= 1<<2,
 
-	BIG		= (1<<12)-4,
 	STRINGSZ	= 200,
 	NHASH		= 10007,
 	NHUNK		= 100000,
@@ -279,9 +281,7 @@ enum
 	NENT		= 100,
 	MAXIO		= 8192,
 	MAXHIST		= 20,	/* limit of path elements for history symbols */
-
-	Roffset	= 22,		/* no. bits for offset in relocation address */
-	Rindex	= 10,		/* no. bits for index in relocation address */
+	MINLC	= 4,
 };
 
 EXTERN union
@@ -310,23 +310,18 @@ EXTERN	int32	INITTEXT;		/* text location */
 EXTERN	char*	INITENTRY;		/* entry point */
 EXTERN	int32	autosize;
 EXTERN	Biobuf	bso;
-EXTERN	int32	bsssize;
 EXTERN	int	cbc;
 EXTERN	uchar*	cbp;
 EXTERN	int	cout;
 EXTERN	Auto*	curauto;
 EXTERN	Auto*	curhist;
 EXTERN	Prog*	curp;
-EXTERN	Prog*	curtext;
-EXTERN	Prog*	datap;
-EXTERN	int32	datsize;
+EXTERN	Sym*	cursym;
+EXTERN	Sym*	datap;
 EXTERN	int32 	elfdatsize;
 EXTERN	char	debug[128];
-EXTERN	Prog*	edatap;
-EXTERN	Prog*	etextp;
-EXTERN	Prog*	firstp;
+EXTERN	Sym*	etextp;
 EXTERN	char*	noname;
-EXTERN	int	xrefresolv;
 EXTERN	Prog*	lastp;
 EXTERN	int32	lcsize;
 EXTERN	char	literal[32];
@@ -341,7 +336,7 @@ EXTERN	uchar	repop[ALAST];
 EXTERN	char*	rpath;
 EXTERN	uint32	stroffset;
 EXTERN	int32	symsize;
-EXTERN	Prog*	textp;
+EXTERN	Sym*	textp;
 EXTERN	int32	textsize;
 EXTERN	int	version;
 EXTERN	char	xcmp[C_GOK+1][C_GOK+1];
@@ -352,14 +347,6 @@ EXTERN	int	thumb;
 EXTERN	int	seenthumb;
 EXTERN	int	armsize;
 
-EXTERN	int	doexp, dlm;
-EXTERN	int	imports, nimports;
-EXTERN	int	exports, nexports;
-EXTERN	char*	EXPTAB;
-EXTERN	Prog	undefp;
-
-#define	UP	(&undefp)
-
 extern	char*	anames[];
 extern	Optab	optab[];
 extern	Optab	thumboptab[];
@@ -384,6 +371,7 @@ EXTERN	Prog*	prog_modu;
 int	Aconv(Fmt*);
 int	Cconv(Fmt*);
 int	Dconv(Fmt*);
+int	Iconv(Fmt*);
 int	Nconv(Fmt*);
 int	Oconv(Fmt*);
 int	Pconv(Fmt*);
@@ -393,36 +381,29 @@ int	thumbaclass(Adr*, Prog*);
 void	addhist(int32, int);
 Prog*	appendp(Prog*);
 void	asmb(void);
-void	asmdyn(void);
-void	asmlc(void);
 void	asmthumbmap(void);
-void	asmout(Prog*, Optab*);
+void	asmout(Prog*, Optab*, int32*);
 void	thumbasmout(Prog*, Optab*);
-void	asmsym(void);
 int32	atolwhex(char*);
 Prog*	brloop(Prog*);
 void	buildop(void);
 void	thumbbuildop(void);
 void	buildrep(int, int);
 void	cflush(void);
-void	ckoff(Sym*, int32);
+int	chipzero(Ieee*);
 int	chipfloat(Ieee*);
 int	cmp(int, int);
 int	compound(Prog*);
 double	cputime(void);
-void	datblk(int32, int32, int);
 void	diag(char*, ...);
 void	divsig(void);
 void	dodata(void);
 void	doprof1(void);
 void	doprof2(void);
-void	dynreloc(Sym*, int32, int);
 int32	entryvalue(void);
 void	exchange(Prog*);
-void	export(void);
 void	follow(void);
 void	hputl(int);
-void	import(void);
 int	isnop(Prog*);
 void	listinit(void);
 Sym*	lookup(char*, int);
@@ -430,10 +411,8 @@ void	cput(int);
 void	hput(int32);
 void	lput(int32);
 void	lputl(int32);
-void	mkfwd(void);
 void*	mysbrk(uint32);
 void	names(void);
-Prog*	newdata(Sym *s, int o, int w, int t);
 void	nocache(Prog*);
 int	ocmp(const void*, const void*);
 int32	opirr(int);
@@ -454,18 +433,17 @@ void	prasm(Prog*);
 void	prepend(Prog*, Prog*);
 Prog*	prg(void);
 int	pseudo(Prog*);
-void	putsymb(char*, int, int32, int);
 int32	regoff(Adr*);
 int	relinv(int);
 int32	rnd(int32, int32);
 void	softfloat(void);
 void	span(void);
 void	strnput(char*, int);
+int32	symaddr(Sym*);
 void	undef(void);
 void	wput(int32);
 void    wputl(ushort w);
 void	xdefine(char*, int, int32);
-void	xfol(Prog*);
 void	noops(void);
 int32	immrot(uint32);
 int32	immaddr(int32);
@@ -475,7 +453,6 @@ int	isbranch(Prog*);
 int	fnpinc(Sym *);
 int	fninc(Sym *);
 void	thumbcount(void);
-void reachable(void);
 void fnptrs(void);
 void	doelf(void);
 
diff --git a/src/cmd/5l/list.c b/src/cmd/5l/list.c
index 9cbb5501c..b4df89587 100644
--- a/src/cmd/5l/list.c
+++ b/src/cmd/5l/list.c
@@ -28,6 +28,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+// Printing.
+
 #include "l.h"
 #include "../ld/lib.h"
 
@@ -42,6 +44,7 @@ listinit(void)
 	fmtinstall('S', Sconv);
 	fmtinstall('N', Nconv);
 	fmtinstall('O', Oconv);		// C_type constants
+	fmtinstall('I', Iconv);
 }
 
 void
@@ -53,7 +56,6 @@ prasm(Prog *p)
 int
 Pconv(Fmt *fp)
 {
-	char str[STRINGSZ], *s;
 	Prog *p;
 	int a;
 
@@ -62,42 +64,41 @@ Pconv(Fmt *fp)
 	a = p->as;
 	switch(a) {
 	default:
-		s = str;
-		s += sprint(s, "(%d)", p->line);
+		fmtprint(fp, "(%d)", p->line);
 		if(p->reg == NREG)
-			sprint(s, "	%A%C	%D,%D",
+			fmtprint(fp, "	%A%C	%D,%D",
 				a, p->scond, &p->from, &p->to);
 		else
 		if(p->from.type != D_FREG)
-			sprint(s, "	%A%C	%D,R%d,%D",
+			fmtprint(fp, "	%A%C	%D,R%d,%D",
 				a, p->scond, &p->from, p->reg, &p->to);
 		else
-			sprint(s, "	%A%C	%D,F%d,%D",
+			fmtprint(fp, "	%A%C	%D,F%d,%D",
 				a, p->scond, &p->from, p->reg, &p->to);
 		break;
 
 	case ASWPW:
 	case ASWPBU:
-		sprint(str, "(%d)	%A%C	R%d,%D,%D",
+		fmtprint(fp, "(%d)	%A%C	R%d,%D,%D",
 			p->line, a, p->scond, p->reg, &p->from, &p->to);
 		break;
 
 	case ADATA:
-	case AINIT:
-	case ADYNT:
-		sprint(str, "(%d)	%A%C	%D/%d,%D",
+	case AINIT_:
+	case ADYNT_:
+		fmtprint(fp, "(%d)	%A%C	%D/%d,%D",
 			p->line, a, p->scond, &p->from, p->reg, &p->to);
 		break;
 
 	case AWORD:
-		sprint(str, "WORD %x", p->to.offset);
+		fmtprint(fp, "(%d)	WORD	%D", p->line, &p->to);
 		break;
 
 	case ADWORD:
-		sprint(str, "DWORD %x %x", p->from.offset, p->to.offset);
+		fmtprint(fp, "(%d)	DWORD	%D %D", p->line, &p->from, &p->to);
 		break;
 	}
-	return fmtstrcpy(fp, str);
+	return 0;
 }
 
 int
@@ -164,98 +165,98 @@ Dconv(Fmt *fp)
 	switch(a->type) {
 
 	default:
-		sprint(str, "GOK-type(%d)", a->type);
+		snprint(str, sizeof str, "GOK-type(%d)", a->type);
 		break;
 
 	case D_NONE:
 		str[0] = 0;
 		if(a->name != D_NONE || a->reg != NREG || a->sym != S)
-			sprint(str, "%N(R%d)(NONE)", a, a->reg);
+			snprint(str, sizeof str, "%N(R%d)(NONE)", a, a->reg);
 		break;
 
 	case D_CONST:
 		if(a->reg == NREG)
-			sprint(str, "$%N", a);
+			snprint(str, sizeof str, "$%N", a);
 		else
-			sprint(str, "$%N(R%d)", a, a->reg);
+			snprint(str, sizeof str, "$%N(R%d)", a, a->reg);
 		break;
 
 	case D_CONST2:
-		sprint(str, "$%d-%d", a->offset, a->offset2);
+		snprint(str, sizeof str, "$%d-%d", a->offset, a->offset2);
 		break;
 
 	case D_SHIFT:
 		v = a->offset;
 		op = "<<>>->@>" + (((v>>5) & 3) << 1);
 		if(v & (1<<4))
-			sprint(str, "R%d%c%cR%d", v&15, op[0], op[1], (v>>8)&15);
+			snprint(str, sizeof str, "R%d%c%cR%d", v&15, op[0], op[1], (v>>8)&15);
 		else
-			sprint(str, "R%d%c%c%d", v&15, op[0], op[1], (v>>7)&31);
+			snprint(str, sizeof str, "R%d%c%c%d", v&15, op[0], op[1], (v>>7)&31);
 		if(a->reg != NREG)
-			sprint(str+strlen(str), "(R%d)", a->reg);
+			seprint(str+strlen(str), str+sizeof str, "(R%d)", a->reg);
 		break;
 
 	case D_OCONST:
-		sprint(str, "$*$%N", a);
+		snprint(str, sizeof str, "$*$%N", a);
 		if(a->reg != NREG)
-			sprint(str, "%N(R%d)(CONST)", a, a->reg);
+			snprint(str, sizeof str, "%N(R%d)(CONST)", a, a->reg);
 		break;
 
 	case D_OREG:
 		if(a->reg != NREG)
-			sprint(str, "%N(R%d)", a, a->reg);
+			snprint(str, sizeof str, "%N(R%d)", a, a->reg);
 		else
-			sprint(str, "%N", a);
+			snprint(str, sizeof str, "%N", a);
 		break;
 
 	case D_REG:
-		sprint(str, "R%d", a->reg);
+		snprint(str, sizeof str, "R%d", a->reg);
 		if(a->name != D_NONE || a->sym != S)
-			sprint(str, "%N(R%d)(REG)", a, a->reg);
+			snprint(str, sizeof str, "%N(R%d)(REG)", a, a->reg);
 		break;
 
 	case D_REGREG:
-		sprint(str, "(R%d,R%d)", a->reg, (int)a->offset);
+		snprint(str, sizeof str, "(R%d,R%d)", a->reg, (int)a->offset);
 		if(a->name != D_NONE || a->sym != S)
-			sprint(str, "%N(R%d)(REG)", a, a->reg);
+			snprint(str, sizeof str, "%N(R%d)(REG)", a, a->reg);
 		break;
 
 	case D_FREG:
-		sprint(str, "F%d", a->reg);
+		snprint(str, sizeof str, "F%d", a->reg);
 		if(a->name != D_NONE || a->sym != S)
-			sprint(str, "%N(R%d)(REG)", a, a->reg);
+			snprint(str, sizeof str, "%N(R%d)(REG)", a, a->reg);
 		break;
 
 	case D_PSR:
 		switch(a->reg) {
 		case 0:
-			sprint(str, "CPSR");
+			snprint(str, sizeof str, "CPSR");
 			break;
 		case 1:
-			sprint(str, "SPSR");
+			snprint(str, sizeof str, "SPSR");
 			break;
 		default:
-			sprint(str, "PSR%d", a->reg);
+			snprint(str, sizeof str, "PSR%d", a->reg);
 			break;
 		}
 		if(a->name != D_NONE || a->sym != S)
-			sprint(str, "%N(PSR%d)(REG)", a, a->reg);
+			snprint(str, sizeof str, "%N(PSR%d)(REG)", a, a->reg);
 		break;
 
 	case D_FPCR:
 		switch(a->reg){
 		case 0:
-			sprint(str, "FPSR");
+			snprint(str, sizeof str, "FPSR");
 			break;
 		case 1:
-			sprint(str, "FPCR");
+			snprint(str, sizeof str, "FPCR");
 			break;
 		default:
-			sprint(str, "FCR%d", a->reg);
+			snprint(str, sizeof str, "FCR%d", a->reg);
 			break;
 		}
 		if(a->name != D_NONE || a->sym != S)
-			sprint(str, "%N(FCR%d)(REG)", a, a->reg);
+			snprint(str, sizeof str, "%N(FCR%d)(REG)", a, a->reg);
 
 		break;
 
@@ -263,22 +264,22 @@ Dconv(Fmt *fp)
 		if(curp->cond != P) {
 			v = curp->cond->pc;
 			if(a->sym != S)
-				sprint(str, "%s+%.5lux(BRANCH)", a->sym->name, v);
+				snprint(str, sizeof str, "%s+%.5ux(BRANCH)", a->sym->name, v);
 			else
-				sprint(str, "%.5lux(BRANCH)", v);
+				snprint(str, sizeof str, "%.5ux(BRANCH)", v);
 		} else
 			if(a->sym != S)
-				sprint(str, "%s+%d(APC)", a->sym->name, a->offset);
+				snprint(str, sizeof str, "%s+%d(APC)", a->sym->name, a->offset);
 			else
-				sprint(str, "%d(APC)", a->offset);
+				snprint(str, sizeof str, "%d(APC)", a->offset);
 		break;
 
 	case D_FCONST:
-		sprint(str, "$%e", ieeedtod(a->ieee));
+		snprint(str, sizeof str, "$%e", ieeedtod(&a->ieee));
 		break;
 
 	case D_SCONST:
-		sprint(str, "$\"%S\"", a->sval);
+		snprint(str, sizeof str, "$\"%S\"", a->sval);
 		break;
 	}
 	return fmtstrcpy(fp, str);
@@ -374,15 +375,45 @@ Sconv(Fmt *fp)
 	return fmtstrcpy(fp, str);
 }
 
+int
+Iconv(Fmt *fp)
+{
+	int i, n;
+	uint32 *p;
+	char *s;
+	Fmt fmt;
+	
+	n = fp->prec;
+	fp->prec = 0;
+	if(!(fp->flags&FmtPrec) || n < 0)
+		return fmtstrcpy(fp, "%I");
+	fp->flags &= ~FmtPrec;
+	p = va_arg(fp->args, uint32*);
+
+	// format into temporary buffer and
+	// call fmtstrcpy to handle padding.
+	fmtstrinit(&fmt);
+	for(i=0; i<n/4; i++) {
+		if(i > 0)
+			fmtprint(&fmt, " ");
+		fmtprint(&fmt, "%.8ux", *p++);
+	}
+	s = fmtstrflush(&fmt);
+	fmtstrcpy(fp, s);
+	free(s);
+	return 0;
+}
+
 static char*
 cnames[] =
 {
 	[C_ADDR]	= "C_ADDR",
 	[C_BCON]	= "C_BCON",
 	[C_FAUTO]	= "C_FAUTO",
-	[C_FCON]	= "C_FCON",
+	[C_ZFCON]	= "C_SFCON",
+	[C_SFCON]	= "C_SFCON",
+	[C_LFCON]	= "C_LFCON",
 	[C_FCR]		= "C_FCR",
-	[C_FEXT]	= "C_FEXT",
 	[C_FOREG]	= "C_FOREG",
 	[C_FREG]	= "C_FREG",
 	[C_GACON]	= "C_GACON",
@@ -391,9 +422,7 @@ cnames[] =
 	[C_GOK]		= "C_GOK",
 	[C_GOREG]	= "C_GOREG",
 	[C_HAUTO]	= "C_HAUTO",
-	[C_HEXT]	= "C_HEXT",
 	[C_HFAUTO]	= "C_HFAUTO",
-	[C_HFEXT]	= "C_HFEXT",
 	[C_HFOREG]	= "C_HFOREG",
 	[C_HOREG]	= "C_HOREG",
 	[C_HREG]	= "C_HREG",
@@ -401,8 +430,6 @@ cnames[] =
 	[C_LAUTO]	= "C_LAUTO",
 	[C_LBRA]	= "C_LBRA",
 	[C_LCON]	= "C_LCON",
-	[C_LECON]	= "C_LECON",
-	[C_LEXT]	= "C_LEXT",
 	[C_LOREG]	= "C_LOREG",
 	[C_NCON]	= "C_NCON",
 	[C_NONE]	= "C_NONE",
@@ -411,7 +438,6 @@ cnames[] =
 	[C_PSR]		= "C_PSR",
 	[C_RACON]	= "C_RACON",
 	[C_RCON]	= "C_RCON",
-	[C_RECON]	= "C_RECON",
 	[C_REG]		= "C_REG",
 	[C_REGREG]	= "C_REGREG",
 	[C_ROREG]	= "C_ROREG",
@@ -419,7 +445,6 @@ cnames[] =
 	[C_SAUTO]	= "C_SAUTO",
 	[C_SBRA]	= "C_SBRA",
 	[C_SCON]	= "C_SCON",
-	[C_SEXT]	= "C_SEXT",
 	[C_SHIFT]	= "C_SHIFT",
 	[C_SOREG]	= "C_SOREG",
 	[C_SP]		= "C_SP",
@@ -443,19 +468,22 @@ Oconv(Fmt *fp)
 void
 diag(char *fmt, ...)
 {
-	char buf[STRINGSZ], *tn;
+	char buf[STRINGSZ], *tn, *sep;
 	va_list arg;
 
-	tn = "??none??";
-	if(curtext != P && curtext->from.sym != S)
-		tn = curtext->from.sym->name;
+	tn = "";
+	sep = "";
+	if(cursym != S) {
+		tn = cursym->name;
+		sep = ": ";
+	}
 	va_start(arg, fmt);
 	vseprint(buf, buf+sizeof(buf), fmt, arg);
 	va_end(arg);
-	print("%s: %s\n", tn, buf);
+	print("%s%s%s\n", tn, sep, buf);
 
 	nerrors++;
-	if(nerrors > 10) {
+	if(nerrors > 20) {
 		print("too many errors\n");
 		errorexit();
 	}
diff --git a/src/cmd/5l/noop.c b/src/cmd/5l/noop.c
index 41d235a09..5def0d3f1 100644
--- a/src/cmd/5l/noop.c
+++ b/src/cmd/5l/noop.c
@@ -28,12 +28,16 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+// Code transformations.
+
 #include	"l.h"
+#include	"../ld/lib.h"
 
 // see ../../runtime/proc.c:/StackGuard
 enum
 {
 	StackBig = 4096,
+	StackSmall = 128,
 };
 
 static	Sym*	sym_div;
@@ -110,14 +114,12 @@ void
 noops(void)
 {
 	Prog *p, *q, *q1, *q2;
-	int o, curframe, curbecome, maxbecome, foreign;
+	int o, foreign;
 	Prog *pmorestack;
 	Sym *symmorestack;
 
 	/*
 	 * find leaf subroutines
-	 * become sizes
-	 * frame sizes
 	 * strip NOPs
 	 * expand RET
 	 * expand BECOME pseudo
@@ -127,780 +129,662 @@ noops(void)
 		Bprint(&bso, "%5.2f noops\n", cputime());
 	Bflush(&bso);
 
-	pmorestack = P;
 	symmorestack = lookup("runtime.morestack", 0);
-
-	if(symmorestack->type == STEXT)
-	for(p = firstp; p != P; p = p->link) {
-		if(p->as == ATEXT) {
-			if(p->from.sym == symmorestack) {
-				pmorestack = p;
-				p->reg |= NOSPLIT;
-				break;
-			}
-		}
+	if(symmorestack->type != STEXT) {
+		diag("runtime·morestack not defined");
+		errorexit();
 	}
-	// TODO(kaib): make lack of morestack an error
-//	if(pmorestack == P)
-//		diag("runtime·morestack not defined");
-
-	curframe = 0;
-	curbecome = 0;
-	maxbecome = 0;
-	curtext = 0;
+	pmorestack = symmorestack->text;
+	pmorestack->reg |= NOSPLIT;
 
 	q = P;
-	for(p = firstp; p != P; p = p->link) {
-		setarch(p);
-
-		/* find out how much arg space is used in this TEXT */
-		if(p->to.type == D_OREG && p->to.reg == REGSP)
-			if(p->to.offset > curframe)
-				curframe = p->to.offset;
-
-		switch(p->as) {
-		case ATEXT:
-			if(curtext && curtext->from.sym) {
-				curtext->from.sym->frame = curframe;
-				curtext->from.sym->become = curbecome;
-				if(curbecome > maxbecome)
-					maxbecome = curbecome;
-			}
-			curframe = 0;
-			curbecome = 0;
-
-			p->mark |= LEAF;
-			curtext = p;
-			break;
-
-		case ARET:
-			/* special form of RET is BECOME */
-			if(p->from.type == D_CONST)
-				if(p->from.offset > curbecome)
-					curbecome = p->from.offset;
-			break;
-
-		case ADIV:
-		case ADIVU:
-		case AMOD:
-		case AMODU:
-			q = p;
-			if(prog_div == P)
-				initdiv();
-			if(curtext != P)
-				curtext->mark &= ~LEAF;
-			setdiv(p->as);
-			continue;
-
-		case ANOP:
-			q1 = p->link;
-			q->link = q1;		/* q is non-nop */
-			q1->mark |= p->mark;
-			continue;
-
-		case ABL:
-		case ABX:
-			if(curtext != P)
-				curtext->mark &= ~LEAF;
-
-		case ABCASE:
-		case AB:
-
-		case ABEQ:
-		case ABNE:
-		case ABCS:
-		case ABHS:
-		case ABCC:
-		case ABLO:
-		case ABMI:
-		case ABPL:
-		case ABVS:
-		case ABVC:
-		case ABHI:
-		case ABLS:
-		case ABGE:
-		case ABLT:
-		case ABGT:
-		case ABLE:
-
-			q1 = p->cond;
-			if(q1 != P) {
-				while(q1->as == ANOP) {
-					q1 = q1->link;
-					p->cond = q1;
-				}
-			}
-			break;
-		}
-		q = p;
-	}
-
-	if(curtext && curtext->from.sym) {
-		curtext->from.sym->frame = curframe;
-		curtext->from.sym->become = curbecome;
-		if(curbecome > maxbecome)
-			maxbecome = curbecome;
-	}
-
-	if(debug['b'])
-		print("max become = %d\n", maxbecome);
-	xdefine("ALEFbecome", STEXT, maxbecome);
-
-	curtext = 0;
-	for(p = firstp; p != P; p = p->link) {
-		setarch(p);
-		switch(p->as) {
-		case ATEXT:
-			curtext = p;
-			break;
-		case ABL:
-		// case ABX:
-			if(curtext != P && curtext->from.sym != S && curtext->to.offset >= 0) {
-				o = maxbecome - curtext->from.sym->frame;
-				if(o <= 0)
-					break;
-				/* calling a become or calling a variable */
-				if(p->to.sym == S || p->to.sym->become) {
-					curtext->to.offset += o;
-					if(debug['b']) {
-						curp = p;
-						print("%D calling %D increase %d\n",
-							&curtext->from, &p->to, o);
+	for(cursym = textp; cursym != nil; cursym = cursym->next) {
+		for(p = cursym->text; p != P; p = p->link) {
+			setarch(p);
+	
+			switch(p->as) {
+			case ATEXT:
+				p->mark |= LEAF;
+				break;
+	
+			case ARET:
+				break;
+	
+			case ADIV:
+			case ADIVU:
+			case AMOD:
+			case AMODU:
+				q = p;
+				if(prog_div == P)
+					initdiv();
+				cursym->text->mark &= ~LEAF;
+				setdiv(p->as);
+				continue;
+	
+			case ANOP:
+				q1 = p->link;
+				q->link = q1;		/* q is non-nop */
+				if(q1 != P)
+					q1->mark |= p->mark;
+				continue;
+	
+			case ABL:
+			case ABX:
+				cursym->text->mark &= ~LEAF;
+	
+			case ABCASE:
+			case AB:
+	
+			case ABEQ:
+			case ABNE:
+			case ABCS:
+			case ABHS:
+			case ABCC:
+			case ABLO:
+			case ABMI:
+			case ABPL:
+			case ABVS:
+			case ABVC:
+			case ABHI:
+			case ABLS:
+			case ABGE:
+			case ABLT:
+			case ABGT:
+			case ABLE:
+				q1 = p->cond;
+				if(q1 != P) {
+					while(q1->as == ANOP) {
+						q1 = q1->link;
+						p->cond = q1;
 					}
 				}
+				break;
 			}
-			break;
+			q = p;
 		}
 	}
 
-	for(p = firstp; p != P; p = p->link) {
-		setarch(p);
-		o = p->as;
-		switch(o) {
-		case ATEXT:
-			curtext = p;
-			autosize = p->to.offset + 4;
-			if(autosize <= 4)
-			if(curtext->mark & LEAF) {
-				p->to.offset = -4;
-				autosize = 0;
-			}
-
-			if(!autosize && !(curtext->mark & LEAF)) {
-				if(debug['v'])
-					Bprint(&bso, "save suppressed in: %s\n",
-						curtext->from.sym->name);
-				Bflush(&bso);
-				curtext->mark |= LEAF;
-			}
+	for(cursym = textp; cursym != nil; cursym = cursym->next) {
+		for(p = cursym->text; p != P; p = p->link) {
+			setarch(p);
+			o = p->as;
+			switch(o) {
+			case ATEXT:
+				autosize = p->to.offset + 4;
+				if(autosize <= 4)
+				if(cursym->text->mark & LEAF) {
+					p->to.offset = -4;
+					autosize = 0;
+				}
+	
+				if(!autosize && !(cursym->text->mark & LEAF)) {
+					if(debug['v'])
+						Bprint(&bso, "save suppressed in: %s\n",
+							cursym->name);
+					Bflush(&bso);
+					cursym->text->mark |= LEAF;
+				}
 #ifdef CALLEEBX
-			if(p->from.sym->foreign){
-				if(thumb)
-					// don't allow literal pool to seperate these
-					p = adword(0xe28f7001, 0xe12fff17, p); // arm add 1, pc, r7 and bx r7
-					// p = aword(0xe12fff17, aword(0xe28f7001, p)); // arm add 1, pc, r7 and bx r7
-				else
-					p = aword(0x4778, p);	// thumb bx pc and 2 bytes padding
-			}
+				if(p->from.sym->foreign){
+					if(thumb)
+						// don't allow literal pool to seperate these
+						p = adword(0xe28f7001, 0xe12fff17, p); // arm add 1, pc, r7 and bx r7
+						// p = aword(0xe12fff17, aword(0xe28f7001, p)); // arm add 1, pc, r7 and bx r7
+					else
+						p = aword(0x4778, p);	// thumb bx pc and 2 bytes padding
+				}
 #endif
-			if(curtext->mark & LEAF) {
-				if(curtext->from.sym)
-					curtext->from.sym->type = SLEAF;
-				if(!autosize)
+				if(cursym->text->mark & LEAF) {
+					cursym->leaf = 1;
+					if(!autosize)
+						break;
+				}
+	
+				if(thumb){
+					if(!(p->reg & NOSPLIT))
+						diag("stack splitting not supported in thumb");
+					if(!(cursym->text->mark & LEAF)){
+						q = movrr(nil, REGLINK, REGTMPT-1, p);
+						p->link = q;
+						q1 = prg();
+						q1->as = AMOVW;
+						q1->line = p->line;
+						q1->from.type = D_REG;
+						q1->from.reg = REGTMPT-1;
+						q1->to.type = D_OREG;
+						q1->to.name = D_NONE;
+						q1->to.reg = REGSP;
+						q1->to.offset = 0;
+						q1->link = q->link;
+						q->link = q1;
+					}
+					if(autosize){
+						q2 = prg();
+						q2->as = ASUB;
+						q2->line = p->line;
+						q2->from.type = D_CONST;
+						q2->from.offset = autosize;
+						q2->to.type = D_REG;
+						q2->to.reg = REGSP;
+						q2->link = p->link;
+						p->link = q2;
+					}
 					break;
-			}
-
-			if(thumb){
-				if(!(p->reg & NOSPLIT))
-					diag("stack splitting not supported in thumb");
-				if(!(curtext->mark & LEAF)){
-					q = movrr(nil, REGLINK, REGTMPT-1, p);
-					p->link = q;
+				}
+	
+				if(p->reg & NOSPLIT) {
 					q1 = prg();
 					q1->as = AMOVW;
+					q1->scond |= C_WBIT;
 					q1->line = p->line;
 					q1->from.type = D_REG;
-					q1->from.reg = REGTMPT-1;
+					q1->from.reg = REGLINK;
 					q1->to.type = D_OREG;
-					q1->to.name = D_NONE;
+					q1->to.offset = -autosize;
 					q1->to.reg = REGSP;
-					q1->to.offset = 0;
-					q1->link = q->link;
-					q->link = q1;
-				}
-				if(autosize){
-					q2 = prg();
-					q2->as = ASUB;
-					q2->line = p->line;
-					q2->from.type = D_CONST;
-					q2->from.offset = autosize;
-					q2->to.type = D_REG;
-					q2->to.reg = REGSP;
-					q2->link = p->link;
-					p->link = q2;
+					q1->link = p->link;
+					p->link = q1;
+				} else if (autosize < StackBig) {
+					// split stack check for small functions
+					// MOVW			g_stackguard(g), R1
+					// CMP			R1, $-autosize(SP)
+					// MOVW.LO		$autosize, R1
+					// MOVW.LO		$args, R2
+					// MOVW.LO		R14, R3
+					// BL.LO			runtime.morestack(SB) // modifies LR
+					// MOVW.W		R14,$-autosize(SP)
+	
+					// TODO(kaib): add more trampolines
+					// TODO(kaib): put stackguard in register
+					// TODO(kaib): add support for -K and underflow detection
+
+					// MOVW			g_stackguard(g), R1
+					p = appendp(p);
+					p->as = AMOVW;
+					p->from.type = D_OREG;
+					p->from.reg = REGG;
+					p->to.type = D_REG;
+					p->to.reg = 1;
+					
+					if(autosize < StackSmall) {	
+						// CMP			R1, SP
+						p = appendp(p);
+						p->as = ACMP;
+						p->from.type = D_REG;
+						p->from.reg = 1;
+						p->reg = REGSP;
+					} else {
+						// MOVW		$-autosize(SP), R2
+						// CMP	R1, R2
+						p = appendp(p);
+						p->as = AMOVW;
+						p->from.type = D_CONST;
+						p->from.reg = REGSP;
+						p->from.offset = -autosize;
+						p->to.type = D_REG;
+						p->to.reg = 2;
+						
+						p = appendp(p);
+						p->as = ACMP;
+						p->from.type = D_REG;
+						p->from.reg = 1;
+						p->reg = 2;
+					}
+	
+					// MOVW.LO		$autosize, R1
+					p = appendp(p);
+					p->as = AMOVW;
+					p->scond = C_SCOND_LO;
+					p->from.type = D_CONST;
+					p->from.offset = 0;
+					p->to.type = D_REG;
+					p->to.reg = 1;
+	
+					// MOVW.LO		$args +4, R2
+					// also need to store the extra 4 bytes.
+					p = appendp(p);
+					p->as = AMOVW;
+					p->scond = C_SCOND_LO;
+					p->from.type = D_CONST;
+					p->from.offset = ((cursym->text->to.offset2 + 3) & ~3) + 4;
+					p->to.type = D_REG;
+					p->to.reg = 2;
+	
+					// MOVW.LO	R14, R3
+					p = appendp(p);
+					p->as = AMOVW;
+					p->scond = C_SCOND_LO;
+					p->from.type = D_REG;
+					p->from.reg = REGLINK;
+					p->to.type = D_REG;
+					p->to.reg = 3;
+	
+					// BL.LO		runtime.morestack(SB) // modifies LR
+					p = appendp(p);
+					p->as = ABL;
+					p->scond = C_SCOND_LO;
+	 				p->to.type = D_BRANCH;
+					p->to.sym = symmorestack;
+					p->cond = pmorestack;
+	
+					// MOVW.W		R14,$-autosize(SP)
+					p = appendp(p);
+					p->as = AMOVW;
+	 				p->scond |= C_WBIT;
+					p->from.type = D_REG;
+					p->from.reg = REGLINK;
+					p->to.type = D_OREG;
+					p->to.offset = -autosize;
+					p->to.reg = REGSP;
+				} else { // > StackBig
+					// MOVW		$autosize, R1
+					// MOVW		$args, R2
+					// MOVW		R14, R3
+					// BL			runtime.morestack(SB) // modifies LR
+					// MOVW.W		R14,$-autosize(SP)
+	
+					// MOVW		$autosize, R1
+					p = appendp(p);
+					p->as = AMOVW;
+					p->from.type = D_CONST;
+					p->from.offset = autosize;
+					p->to.type = D_REG;
+					p->to.reg = 1;
+	
+					// MOVW		$args +4, R2
+					// also need to store the extra 4 bytes.
+					p = appendp(p);
+					p->as = AMOVW;
+					p->from.type = D_CONST;
+					p->from.offset = ((cursym->text->to.offset2 + 3) & ~3) + 4;
+					p->to.type = D_REG;
+					p->to.reg = 2;
+	
+					// MOVW	R14, R3
+					p = appendp(p);
+					p->as = AMOVW;
+					p->from.type = D_REG;
+					p->from.reg = REGLINK;
+					p->to.type = D_REG;
+					p->to.reg = 3;
+	
+					// BL		runtime.morestack(SB) // modifies LR
+					p = appendp(p);
+					p->as = ABL;
+	 				p->to.type = D_BRANCH;
+					p->to.sym = symmorestack;
+					p->cond = pmorestack;
+	
+					// MOVW.W		R14,$-autosize(SP)
+					p = appendp(p);
+					p->as = AMOVW;
+	 				p->scond |= C_WBIT;
+					p->from.type = D_REG;
+					p->from.reg = REGLINK;
+					p->to.type = D_OREG;
+					p->to.offset = -autosize;
+					p->to.reg = REGSP;
 				}
 				break;
-			}
-
-			if(p->reg & NOSPLIT) {
-				q1 = prg();
-				q1->as = AMOVW;
-				q1->scond |= C_WBIT;
-				q1->line = p->line;
-				q1->from.type = D_REG;
-				q1->from.reg = REGLINK;
-				q1->to.type = D_OREG;
-				q1->to.offset = -autosize;
-				q1->to.reg = REGSP;
-				q1->link = p->link;
-				p->link = q1;
-			} else if (autosize < StackBig) {
-				// split stack check for small functions
-				// MOVW			g_stackguard(g), R1
-				// CMP			R1, $-autosize(SP)
-				// MOVW.LO		$autosize, R1
-				// MOVW.LO		$args, R2
-				// MOVW.LO		R14, R3
-				// BL.LO			runtime.morestack(SB) // modifies LR
-				// MOVW.W		R14,$-autosize(SP)
-
-				// TODO(kaib): add more trampolines
-				// TODO(kaib): put stackguard in register
-				// TODO(kaib): add support for -K and underflow detection
-
-				// MOVW			g_stackguard(g), R1
-				p = appendp(p);
-				p->as = AMOVW;
-				p->from.type = D_OREG;
-				p->from.reg = REGG;
-				p->to.type = D_REG;
-				p->to.reg = 1;
-
-				// CMP			R1, $-autosize(SP)
-				p = appendp(p);
-				p->as = ACMP;
-				p->from.type = D_REG;
-				p->from.reg = 1;
-				p->from.offset = -autosize;
-				p->reg = REGSP;
-
-				// MOVW.LO		$autosize, R1
-				p = appendp(p);
-				p->as = AMOVW;
-				p->scond = C_SCOND_LO;
-				p->from.type = D_CONST;
-				p->from.offset = 0;
-				p->to.type = D_REG;
-				p->to.reg = 1;
-
-				// MOVW.LO		$args +4, R2
-				// also need to store the extra 4 bytes.
-				p = appendp(p);
-				p->as = AMOVW;
-				p->scond = C_SCOND_LO;
-				p->from.type = D_CONST;
-				p->from.offset = ((curtext->to.offset2 + 3) & ~3) + 4;
-				p->to.type = D_REG;
-				p->to.reg = 2;
-
-				// MOVW.LO	R14, R3
-				p = appendp(p);
-				p->as = AMOVW;
-				p->scond = C_SCOND_LO;
-				p->from.type = D_REG;
-				p->from.reg = REGLINK;
-				p->to.type = D_REG;
-				p->to.reg = 3;
-
-				// BL.LO		runtime.morestack(SB) // modifies LR
-				p = appendp(p);
-				p->as = ABL;
-				p->scond = C_SCOND_LO;
- 				p->to.type = D_BRANCH;
-				p->to.sym = symmorestack;
-				p->cond = pmorestack;
-
-				// MOVW.W		R14,$-autosize(SP)
-				p = appendp(p);
-				p->as = AMOVW;
- 				p->scond |= C_WBIT;
-				p->from.type = D_REG;
-				p->from.reg = REGLINK;
-				p->to.type = D_OREG;
-				p->to.offset = -autosize;
-				p->to.reg = REGSP;
-			} else { // > StackBig
-				// MOVW		$autosize, R1
-				// MOVW		$args, R2
-				// MOVW		R14, R3
-				// BL			runtime.morestack(SB) // modifies LR
-				// MOVW.W		R14,$-autosize(SP)
-
-				// MOVW		$autosize, R1
-				p = appendp(p);
-				p->as = AMOVW;
-				p->from.type = D_CONST;
-				p->from.offset = autosize;
-				p->to.type = D_REG;
-				p->to.reg = 1;
-
-				// MOVW		$args +4, R2
-				// also need to store the extra 4 bytes.
-				p = appendp(p);
-				p->as = AMOVW;
-				p->from.type = D_CONST;
-				p->from.offset = ((curtext->to.offset2 + 3) & ~3) + 4;
-				p->to.type = D_REG;
-				p->to.reg = 2;
-
-				// MOVW	R14, R3
-				p = appendp(p);
-				p->as = AMOVW;
-				p->from.type = D_REG;
-				p->from.reg = REGLINK;
-				p->to.type = D_REG;
-				p->to.reg = 3;
-
-				// BL		runtime.morestack(SB) // modifies LR
-				p = appendp(p);
-				p->as = ABL;
- 				p->to.type = D_BRANCH;
-				p->to.sym = symmorestack;
-				p->cond = pmorestack;
-
-				// MOVW.W		R14,$-autosize(SP)
-				p = appendp(p);
-				p->as = AMOVW;
- 				p->scond |= C_WBIT;
-				p->from.type = D_REG;
-				p->from.reg = REGLINK;
-				p->to.type = D_OREG;
-				p->to.offset = -autosize;
-				p->to.reg = REGSP;
-			}
-			break;
-
-		case ARET:
-			nocache(p);
-			foreign = seenthumb && curtext->from.sym != S && (curtext->from.sym->foreign || curtext->from.sym->fnptr);
-// print("%s %d %d\n", curtext->from.sym->name, curtext->from.sym->foreign, curtext->from.sym->fnptr);
-			if(p->from.type == D_CONST)
-				goto become;
-			if(curtext->mark & LEAF) {
-				if(!autosize) {
-					if(thumb){
-						p = fnret(p, REGLINK, foreign, p);
+	
+			case ARET:
+				nocache(p);
+				foreign = seenthumb && (cursym->foreign || cursym->fnptr);
+// print("%s %d %d\n", cursym->name, cursym->foreign, cursym->fnptr);
+				if(cursym->text->mark & LEAF) {
+					if(!autosize) {
+						if(thumb){
+							p = fnret(p, REGLINK, foreign, p);
+							break;
+						}
+// if(foreign) print("ABXRET 1 %s\n", cursym->name);
+						p->as = foreign ? ABXRET : AB;
+						p->from = zprg.from;
+						p->to.type = D_OREG;
+						p->to.offset = 0;
+						p->to.reg = REGLINK;
 						break;
 					}
-// if(foreign) print("ABXRET 1 %s\n", curtext->from.sym->name);
-					p->as = foreign ? ABXRET : AB;
-					p->from = zprg.from;
-					p->to.type = D_OREG;
-					p->to.offset = 0;
-					p->to.reg = REGLINK;
-					break;
 				}
-			}
-			if(thumb){
-				if(curtext->mark & LEAF){
-					if(autosize){
-						p->as = AADD;
-						p->from.type = D_CONST;
-						p->from.offset = autosize;
+				if(thumb){
+					if(cursym->text->mark & LEAF){
+						if(autosize){
+							p->as = AADD;
+							p->from.type = D_CONST;
+							p->from.offset = autosize;
+							p->to.type = D_REG;
+							p->to.reg = REGSP;
+							q = nil;
+						}
+						else
+							q = p;
+						q = fnret(q, REGLINK, foreign, p);
+						if(q != p)
+							p->link = q;
+					}
+					else{
+						p->as = AMOVW;
+						p->from.type = D_OREG;
+						p->from.name = D_NONE;
+						p->from.reg = REGSP;
+						p->from.offset = 0;
 						p->to.type = D_REG;
-						p->to.reg = REGSP;
-						q = nil;
+						p->to.reg = REGTMPT-1;
+						if(autosize){
+							q = prg();
+							q->as = AADD;
+							q->from.type = D_CONST;
+							q->from.offset = autosize;
+							q->to.type = D_REG;
+							q->to.reg = REGSP;
+							q->link = p->link;
+							p->link = 	q;
+						}
+						else
+							q = p;
+						q1 = fnret(nil, REGTMPT-1, foreign, p);
+						q1->link = q->link;
+						q->link = q1;
 					}
-					else
-						q = p;
-					q = fnret(q, REGLINK, foreign, p);
-					if(q != p)
-						p->link = q;
+					break;
 				}
-				else{
+				if(foreign) {
+// if(foreign) print("ABXRET 3 %s\n", cursym->name);
+#define	R	1
 					p->as = AMOVW;
 					p->from.type = D_OREG;
 					p->from.name = D_NONE;
 					p->from.reg = REGSP;
 					p->from.offset = 0;
 					p->to.type = D_REG;
-					p->to.reg = REGTMPT-1;
-					if(autosize){
-						q = prg();
-						q->as = AADD;
-						q->from.type = D_CONST;
-						q->from.offset = autosize;
-						q->to.type = D_REG;
-						q->to.reg = REGSP;
-						q->link = p->link;
-						p->link = 	q;
-					}
-					else
-						q = p;
-					q1 = fnret(nil, REGTMPT-1, foreign, p);
+					p->to.reg = R;
+					q = prg();
+					q->as = AADD;
+					q->scond = p->scond;
+					q->line = p->line;
+					q->from.type = D_CONST;
+					q->from.offset = autosize;
+					q->to.type = D_REG;
+					q->to.reg = REGSP;
+					q->link = p->link;
+					p->link = q;
+					q1 = prg();
+					q1->as = ABXRET;
+					q1->scond = p->scond;
+					q1->line = p->line;
+					q1->to.type = D_OREG;
+					q1->to.offset = 0;
+					q1->to.reg = R;
 					q1->link = q->link;
 					q->link = q1;
+#undef	R
+				}
+				else {
+					p->as = AMOVW;
+					p->scond |= C_PBIT;
+					p->from.type = D_OREG;
+					p->from.offset = autosize;
+					p->from.reg = REGSP;
+					p->to.type = D_REG;
+					p->to.reg = REGPC;
 				}
 				break;
-			}
-			if(foreign) {
-// if(foreign) print("ABXRET 3 %s\n", curtext->from.sym->name);
-#define	R	1
+	
+			case ADIV:
+			case ADIVU:
+			case AMOD:
+			case AMODU:
+				if(debug['M'])
+					break;
+				if(p->from.type != D_REG)
+					break;
+				if(p->to.type != D_REG)
+					break;
+				q1 = p;
+	
+				/* MOV a,4(SP) */
+				q = prg();
+				q->link = p->link;
+				p->link = q;
+				p = q;
+	
 				p->as = AMOVW;
-				p->from.type = D_OREG;
-				p->from.name = D_NONE;
-				p->from.reg = REGSP;
-				p->from.offset = 0;
-				p->to.type = D_REG;
-				p->to.reg = R;
+				p->line = q1->line;
+				p->from.type = D_REG;
+				p->from.reg = q1->from.reg;
+				p->to.type = D_OREG;
+				p->to.reg = REGSP;
+				p->to.offset = 4;
+	
+				/* MOV b,REGTMP */
 				q = prg();
-				q->as = AADD;
-				q->scond = p->scond;
-				q->line = p->line;
-				q->from.type = D_CONST;
-				q->from.offset = autosize;
-				q->to.type = D_REG;
-				q->to.reg = REGSP;
 				q->link = p->link;
 				p->link = q;
-				q1 = prg();
-				q1->as = ABXRET;
-				q1->scond = p->scond;
-				q1->line = p->line;
-				q1->to.type = D_OREG;
-				q1->to.offset = 0;
-				q1->to.reg = R;
-				q1->link = q->link;
-				q->link = q1;
-#undef	R
-			}
-			else {
+				p = q;
+	
 				p->as = AMOVW;
-				p->scond |= C_PBIT;
-				p->from.type = D_OREG;
-				p->from.offset = autosize;
-				p->from.reg = REGSP;
+				p->line = q1->line;
+				p->from.type = D_REG;
+				p->from.reg = q1->reg;
+				if(q1->reg == NREG)
+					p->from.reg = q1->to.reg;
 				p->to.type = D_REG;
-				p->to.reg = REGPC;
-			}
-			break;
-
-		become:
-			if(foreign){
-				diag("foreign become - help");
-				break;
-			}
-			if(thumb){
-				diag("thumb become - help");
-				break;
-			}
-			print("arm become\n");
-			if(curtext->mark & LEAF) {
-
-				if(!autosize) {
-					p->as = AB;
-					p->from = zprg.from;
+				p->to.reg = prog_div->from.sym->thumb ? REGTMPT : REGTMP;
+				p->to.offset = 0;
+	
+				/* CALL appropriate */
+				q = prg();
+				q->link = p->link;
+				p->link = q;
+				p = q;
+	
+#ifdef CALLEEBX
+				p->as = ABL;
+#else
+				if(prog_div->from.sym->thumb)
+					p->as = thumb ? ABL : ABX;
+				else
+					p->as = thumb ? ABX : ABL;
+#endif
+				p->line = q1->line;
+				p->to.type = D_BRANCH;
+				p->cond = p;
+				switch(o) {
+				case ADIV:
+					p->cond = prog_div;
+					p->to.sym = sym_div;
+					break;
+				case ADIVU:
+					p->cond = prog_divu;
+					p->to.sym = sym_divu;
+					break;
+				case AMOD:
+					p->cond = prog_mod;
+					p->to.sym = sym_mod;
+					break;
+				case AMODU:
+					p->cond = prog_modu;
+					p->to.sym = sym_modu;
 					break;
 				}
-			}
-			q = prg();
-			q->scond = p->scond;
-			q->line = p->line;
-			q->as = AB;
-			q->from = zprg.from;
-			q->to = p->to;
-			q->cond = p->cond;
-			q->link = p->link;
-			p->link = q;
-			if(thumb){
-				q1 = prg();
-				q1->line = p->line;
-				q1->as = AADD;
-				q1->from.type = D_CONST;
-				q1->from.offset = autosize;
-				q1->to.type = D_REG;
-				q1->to.reg = REGSP;
+	
+				/* MOV REGTMP, b */
+				q = prg();
+				q->link = p->link;
+				p->link = q;
+				p = q;
+	
 				p->as = AMOVW;
-				p->line = p->line;
-				p->from.type = D_OREG;
-				p->from.name = D_NONE;
-				p->from.reg = REGSP;
+				p->line = q1->line;
+				p->from.type = D_REG;
+				p->from.reg = prog_div->from.sym->thumb ? REGTMPT : REGTMP;
 				p->from.offset = 0;
 				p->to.type = D_REG;
-				p->to.reg = REGTMPT-1;
-				q1->link = q;
-				p->link = q1;
-				q2 = movrr(nil, REGTMPT-1, REGLINK, p);
-				q2->link = q;
-				q1->link = q2;
-				break;
-			}
-			p->as = AMOVW;
-			p->scond |= C_PBIT;
-			p->from = zprg.from;
-			p->from.type = D_OREG;
-			p->from.offset = autosize;
-			p->from.reg = REGSP;
-			p->to = zprg.to;
-			p->to.type = D_REG;
-			p->to.reg = REGLINK;
-
-			break;
-
-		case ADIV:
-		case ADIVU:
-		case AMOD:
-		case AMODU:
-			if(debug['M'])
-				break;
-			if(p->from.type != D_REG)
-				break;
-			if(p->to.type != D_REG)
-				break;
-			q1 = p;
-
-			/* MOV a,4(SP) */
-			q = prg();
-			q->link = p->link;
-			p->link = q;
-			p = q;
-
-			p->as = AMOVW;
-			p->line = q1->line;
-			p->from.type = D_REG;
-			p->from.reg = q1->from.reg;
-			p->to.type = D_OREG;
-			p->to.reg = REGSP;
-			p->to.offset = 4;
-
-			/* MOV b,REGTMP */
-			q = prg();
-			q->link = p->link;
-			p->link = q;
-			p = q;
-
-			p->as = AMOVW;
-			p->line = q1->line;
-			p->from.type = D_REG;
-			p->from.reg = q1->reg;
-			if(q1->reg == NREG)
-				p->from.reg = q1->to.reg;
-			p->to.type = D_REG;
-			p->to.reg = prog_div != UP && prog_div->from.sym->thumb ? REGTMPT : REGTMP;
-			p->to.offset = 0;
-
-			/* CALL appropriate */
-			q = prg();
-			q->link = p->link;
-			p->link = q;
-			p = q;
-
-#ifdef CALLEEBX
-			p->as = ABL;
-#else
-			if(prog_div != UP && prog_div->from.sym->thumb)
-				p->as = thumb ? ABL : ABX;
-			else
-				p->as = thumb ? ABX : ABL;
-#endif
-			p->line = q1->line;
-			p->to.type = D_BRANCH;
-			p->cond = p;
-			switch(o) {
-			case ADIV:
-				p->cond = prog_div;
-				p->to.sym = sym_div;
-				break;
-			case ADIVU:
-				p->cond = prog_divu;
-				p->to.sym = sym_divu;
-				break;
-			case AMOD:
-				p->cond = prog_mod;
-				p->to.sym = sym_mod;
+				p->to.reg = q1->to.reg;
+	
+				/* ADD $8,SP */
+				q = prg();
+				q->link = p->link;
+				p->link = q;
+				p = q;
+	
+				p->as = AADD;
+				p->from.type = D_CONST;
+				p->from.reg = NREG;
+				p->from.offset = 8;
+				p->reg = NREG;
+				p->to.type = D_REG;
+				p->to.reg = REGSP;
+	
+				/* SUB $8,SP */
+				q1->as = ASUB;
+				q1->from.type = D_CONST;
+				q1->from.offset = 8;
+				q1->from.reg = NREG;
+				q1->reg = NREG;
+				q1->to.type = D_REG;
+				q1->to.reg = REGSP;
+	
 				break;
-			case AMODU:
-				p->cond = prog_modu;
-				p->to.sym = sym_modu;
+			case AMOVW:
+				if(thumb){
+					Adr *a = &p->from;
+	
+					if(a->type == D_CONST && ((a->name == D_NONE && a->reg == REGSP) || a->name == D_AUTO || a->name == D_PARAM) && (a->offset & 3))
+						diag("SP offset not multiple of 4");
+				}
 				break;
-			}
-
-			/* MOV REGTMP, b */
-			q = prg();
-			q->link = p->link;
-			p->link = q;
-			p = q;
-
-			p->as = AMOVW;
-			p->line = q1->line;
-			p->from.type = D_REG;
-			p->from.reg = prog_div != UP && prog_div->from.sym->thumb ? REGTMPT : REGTMP;
-			p->from.offset = 0;
-			p->to.type = D_REG;
-			p->to.reg = q1->to.reg;
-
-			/* ADD $8,SP */
-			q = prg();
-			q->link = p->link;
-			p->link = q;
-			p = q;
-
-			p->as = AADD;
-			p->from.type = D_CONST;
-			p->from.reg = NREG;
-			p->from.offset = 8;
-			p->reg = NREG;
-			p->to.type = D_REG;
-			p->to.reg = REGSP;
-
-			/* SUB $8,SP */
-			q1->as = ASUB;
-			q1->from.type = D_CONST;
-			q1->from.offset = 8;
-			q1->from.reg = NREG;
-			q1->reg = NREG;
-			q1->to.type = D_REG;
-			q1->to.reg = REGSP;
-
-			break;
-		case AMOVW:
-			if(thumb){
-				Adr *a = &p->from;
-
-				if(a->type == D_CONST && ((a->name == D_NONE && a->reg == REGSP) || a->name == D_AUTO || a->name == D_PARAM) && (a->offset & 3))
-					diag("SP offset not multiple of 4");
-			}
-			break;
-		case AMOVB:
-		case AMOVBU:
-		case AMOVH:
-		case AMOVHU:
-			if(thumb){
-				if(p->from.type == D_OREG && (p->from.name == D_AUTO || p->from.name == D_PARAM || (p->from.name == D_CONST && p->from.reg == REGSP))){
-					q = prg();
-					*q = *p;
-					if(p->from.name == D_AUTO)
-						q->from.offset += autosize;
-					else if(p->from.name == D_PARAM)
-						q->from.offset += autosize+4;
-					q->from.name = D_NONE;
-					q->from.reg = REGTMPT;
-					p = movrr(p, REGSP, REGTMPT, p);
-					q->link = p->link;
-					p->link = q;
+			case AMOVB:
+			case AMOVBU:
+			case AMOVH:
+			case AMOVHU:
+				if(thumb){
+					if(p->from.type == D_OREG && (p->from.name == D_AUTO || p->from.name == D_PARAM || (p->from.name == D_CONST && p->from.reg == REGSP))){
+						q = prg();
+						*q = *p;
+						if(p->from.name == D_AUTO)
+							q->from.offset += autosize;
+						else if(p->from.name == D_PARAM)
+							q->from.offset += autosize+4;
+						q->from.name = D_NONE;
+						q->from.reg = REGTMPT;
+						p = movrr(p, REGSP, REGTMPT, p);
+						q->link = p->link;
+						p->link = q;
+					}
+					if(p->to.type == D_OREG && (p->to.name == D_AUTO || p->to.name == D_PARAM || (p->to.name == D_CONST && p->to.reg == REGSP))){
+						q = prg();
+						*q = *p;
+						if(p->to.name == D_AUTO)
+							q->to.offset += autosize;
+						else if(p->to.name == D_PARAM)
+							q->to.offset += autosize+4;
+						q->to.name = D_NONE;
+						q->to.reg = REGTMPT;
+						p = movrr(p, REGSP, REGTMPT, p);
+						q->link = p->link;
+						p->link = q;
+						if(q->to.offset < 0 || q->to.offset > 255){	// complicated
+							p->to.reg = REGTMPT+1;			// mov sp, r8
+							q1 = prg();
+							q1->line = p->line;
+							q1->as = AMOVW;
+							q1->from.type = D_CONST;
+							q1->from.offset = q->to.offset;
+							q1->to.type = D_REG;
+							q1->to.reg = REGTMPT;			// mov $o, r7
+							p->link = q1;
+							q1->link = q;
+							q1 = prg();
+							q1->line = p->line;
+							q1->as = AADD;
+							q1->from.type = D_REG;
+							q1->from.reg = REGTMPT+1;
+							q1->to.type = D_REG;
+							q1->to.reg = REGTMPT;			// add r8, r7
+							p->link->link = q1;
+							q1->link = q;
+							q->to.offset = 0;				// mov* r, 0(r7)
+							/* phew */
+						}
+					}
 				}
-				if(p->to.type == D_OREG && (p->to.name == D_AUTO || p->to.name == D_PARAM || (p->to.name == D_CONST && p->to.reg == REGSP))){
-					q = prg();
-					*q = *p;
-					if(p->to.name == D_AUTO)
-						q->to.offset += autosize;
-					else if(p->to.name == D_PARAM)
-						q->to.offset += autosize+4;
-					q->to.name = D_NONE;
-					q->to.reg = REGTMPT;
-					p = movrr(p, REGSP, REGTMPT, p);
-					q->link = p->link;
-					p->link = q;
-					if(q->to.offset < 0 || q->to.offset > 255){	// complicated
-						p->to.reg = REGTMPT+1;			// mov sp, r8
-						q1 = prg();
-						q1->line = p->line;
-						q1->as = AMOVW;
-						q1->from.type = D_CONST;
-						q1->from.offset = q->to.offset;
-						q1->to.type = D_REG;
-						q1->to.reg = REGTMPT;			// mov $o, r7
-						p->link = q1;
-						q1->link = q;
-						q1 = prg();
-						q1->line = p->line;
-						q1->as = AADD;
-						q1->from.type = D_REG;
-						q1->from.reg = REGTMPT+1;
-						q1->to.type = D_REG;
-						q1->to.reg = REGTMPT;			// add r8, r7
-						p->link->link = q1;
-						q1->link = q;
-						q->to.offset = 0;				// mov* r, 0(r7)
-						/* phew */
+				break;
+			case AMOVM:
+				if(thumb){
+					if(p->from.type == D_OREG){
+						if(p->from.offset == 0)
+							p->from.type = D_REG;
+						else
+							diag("non-zero AMOVM offset");
+					}
+					else if(p->to.type == D_OREG){
+						if(p->to.offset == 0)
+							p->to.type = D_REG;
+						else
+							diag("non-zero AMOVM offset");
 					}
 				}
-			}
-			break;
-		case AMOVM:
-			if(thumb){
-				if(p->from.type == D_OREG){
-					if(p->from.offset == 0)
+				break;
+			case AB:
+				if(thumb && p->to.type == D_OREG){
+					if(p->to.offset == 0){
+						p->as = AMOVW;
 						p->from.type = D_REG;
-					else
-						diag("non-zero AMOVM offset");
-				}
-				else if(p->to.type == D_OREG){
-					if(p->to.offset == 0)
+						p->from.reg = p->to.reg;
 						p->to.type = D_REG;
-					else
-						diag("non-zero AMOVM offset");
-				}
-			}
-			break;
-		case AB:
-			if(thumb && p->to.type == D_OREG){
-				if(p->to.offset == 0){
-					p->as = AMOVW;
-					p->from.type = D_REG;
-					p->from.reg = p->to.reg;
-					p->to.type = D_REG;
-					p->to.reg = REGPC;
-				}
-				else{
-					p->as = AADD;
-					p->from.type = D_CONST;
-					p->from.offset = p->to.offset;
-					p->reg = p->to.reg;
-					p->to.type = D_REG;
-					p->to.reg = REGTMPT-1;
-					q = prg();
-					q->as = AMOVW;
-					q->line = p->line;
-					q->from.type = D_REG;
-					q->from.reg = REGTMPT-1;
-					q->to.type = D_REG;
-					q->to.reg = REGPC;
-					q->link = p->link;
-					p->link = q;
+						p->to.reg = REGPC;
+					}
+					else{
+						p->as = AADD;
+						p->from.type = D_CONST;
+						p->from.offset = p->to.offset;
+						p->reg = p->to.reg;
+						p->to.type = D_REG;
+						p->to.reg = REGTMPT-1;
+						q = prg();
+						q->as = AMOVW;
+						q->line = p->line;
+						q->from.type = D_REG;
+						q->from.reg = REGTMPT-1;
+						q->to.type = D_REG;
+						q->to.reg = REGPC;
+						q->link = p->link;
+						p->link = q;
+					}
 				}
-			}
-			if(seenthumb && !thumb && p->to.type == D_OREG && p->to.reg == REGLINK){
-				// print("warn %s:	b	(R%d)	assuming a return\n", curtext->from.sym->name, p->to.reg);
-				p->as = ABXRET;
-			}
-			break;
-		case ABL:
-		case ABX:
-			if(thumb && p->to.type == D_OREG){
-				if(p->to.offset == 0){
-					p->as = o;
-					p->from.type = D_NONE;
-					p->to.type = D_REG;
+				if(seenthumb && !thumb && p->to.type == D_OREG && p->to.reg == REGLINK){
+					// print("warn %s:	b	(R%d)	assuming a return\n", cursym->name, p->to.reg);
+					p->as = ABXRET;
 				}
-				else{
-					p->as = AADD;
-					p->from.type = D_CONST;
-					p->from.offset = p->to.offset;
-					p->reg = p->to.reg;
-					p->to.type = D_REG;
-					p->to.reg = REGTMPT-1;
-					q = prg();
-					q->as = o;
-					q->line = p->line;
-					q->from.type = D_NONE;
-					q->to.type = D_REG;
-					q->to.reg = REGTMPT-1;
-					q->link = p->link;
-					p->link = q;
+				break;
+			case ABL:
+			case ABX:
+				if(thumb && p->to.type == D_OREG){
+					if(p->to.offset == 0){
+						p->as = o;
+						p->from.type = D_NONE;
+						p->to.type = D_REG;
+					}
+					else{
+						p->as = AADD;
+						p->from.type = D_CONST;
+						p->from.offset = p->to.offset;
+						p->reg = p->to.reg;
+						p->to.type = D_REG;
+						p->to.reg = REGTMPT-1;
+						q = prg();
+						q->as = o;
+						q->line = p->line;
+						q->from.type = D_NONE;
+						q->to.type = D_REG;
+						q->to.reg = REGTMPT-1;
+						q->link = p->link;
+						p->link = q;
+					}
 				}
+				break;
 			}
-			break;
 		}
 	}
 }
@@ -911,12 +795,9 @@ sigdiv(char *n)
 	Sym *s;
 
 	s = lookup(n, 0);
-	if(s->type == STEXT){
+	if(s->type == STEXT)
 		if(s->sig == 0)
 			s->sig = SIGNINTERN;
-	}
-	else if(s->type == 0 || s->type == SXREF)
-		s->type = SUNDEF;
 }
 
 void
@@ -928,25 +809,10 @@ divsig(void)
 	sigdiv("_modu");
 }
 
-static void
-sdiv(Sym *s)
-{
-	if(s->type == 0 || s->type == SXREF){
-		/* undefsym(s); */
-		s->type = SXREF;
-		if(s->sig == 0)
-			s->sig = SIGNINTERN;
-		s->subtype = SIMPORT;
-	}
-	else if(s->type != STEXT)
-		diag("undefined: %s", s->name);
-}
-
 void
 initdiv(void)
 {
 	Sym *s2, *s3, *s4, *s5;
-	Prog *p;
 
 	if(prog_div != P)
 		return;
@@ -954,38 +820,25 @@ initdiv(void)
 	sym_divu = s3 = lookup("_divu", 0);
 	sym_mod = s4 = lookup("_mod", 0);
 	sym_modu = s5 = lookup("_modu", 0);
-	if(dlm) {
-		sdiv(s2); if(s2->type == SXREF) prog_div = UP;
-		sdiv(s3); if(s3->type == SXREF) prog_divu = UP;
-		sdiv(s4); if(s4->type == SXREF) prog_mod = UP;
-		sdiv(s5); if(s5->type == SXREF) prog_modu = UP;
-	}
-	for(p = firstp; p != P; p = p->link)
-		if(p->as == ATEXT) {
-			if(p->from.sym == s2)
-				prog_div = p;
-			if(p->from.sym == s3)
-				prog_divu = p;
-			if(p->from.sym == s4)
-				prog_mod = p;
-			if(p->from.sym == s5)
-				prog_modu = p;
-		}
+	prog_div = s2->text;
+	prog_divu = s3->text;
+	prog_mod = s4->text;
+	prog_modu = s5->text;
 	if(prog_div == P) {
 		diag("undefined: %s", s2->name);
-		prog_div = curtext;
+		prog_div = cursym->text;
 	}
 	if(prog_divu == P) {
 		diag("undefined: %s", s3->name);
-		prog_divu = curtext;
+		prog_divu = cursym->text;
 	}
 	if(prog_mod == P) {
 		diag("undefined: %s", s4->name);
-		prog_mod = curtext;
+		prog_mod = cursym->text;
 	}
 	if(prog_modu == P) {
 		diag("undefined: %s", s5->name);
-		prog_modu = curtext;
+		prog_modu = cursym->text;
 	}
 }
 
@@ -1000,7 +853,7 @@ setdiv(int as)
 	case AMOD: p = prog_mod; break;
 	case AMODU: p = prog_modu; break;
 	}
-	if(p != UP && thumb != p->from.sym->thumb)
+	if(thumb != p->from.sym->thumb)
 		p->from.sym->foreign = 1;
 }
 
diff --git a/src/cmd/5l/obj.c b/src/cmd/5l/obj.c
index e3597e040..cb9ad9805 100644
--- a/src/cmd/5l/obj.c
+++ b/src/cmd/5l/obj.c
@@ -28,6 +28,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+// Reading object files.
+
 #define	EXTERN
 #include	"l.h"
 #include	"../ld/lib.h"
@@ -50,28 +52,6 @@ char	*thestring 	= "arm";
  *	-H5 -T0xC0008010 -R1024		is ipaq
  */
 
-static int
-isobjfile(char *f)
-{
-	int n, v;
-	Biobuf *b;
-	char buf1[5], buf2[SARMAG];
-
-	b = Bopen(f, OREAD);
-	if(b == nil)
-		return 0;
-	n = Bread(b, buf1, 5);
-	if(n == 5 && (buf1[2] == 1 && buf1[3] == '<' || buf1[3] == 1 && buf1[4] == '<'))
-		v = 1;	/* good enough for our purposes */
-	else{
-		Bseek(b, 0, 0);
-		n = Bread(b, buf2, SARMAG);
-		v = n == SARMAG && strncmp(buf2, ARMAG, SARMAG) == 0;
-	}
-	Bterm(b);
-	return v;
-}
-
 static char*
 linkername[] =
 {
@@ -94,7 +74,6 @@ main(int argc, char *argv[])
 	cout = -1;
 	listinit();
 	nerrors = 0;
-	curtext = P;
 	outfile = "5.out";
 	HEADTYPE = -1;
 	INITTEXT = -1;
@@ -231,10 +210,10 @@ main(int argc, char *argv[])
 		break;
 	}
 	if(INITDAT != 0 && INITRND != 0)
-		print("warning: -D0x%lux is ignored because of -R0x%lux\n",
+		print("warning: -D0x%ux is ignored because of -R0x%ux\n",
 			INITDAT, INITRND);
 	if(debug['v'])
-		Bprint(&bso, "HEADER = -H0x%d -T0x%lux -D0x%lux -R0x%lux\n",
+		Bprint(&bso, "HEADER = -H0x%d -T0x%ux -D0x%ux -R0x%ux\n",
 			HEADTYPE, INITTEXT, INITDAT, INITRND);
 	Bflush(&bso);
 	zprg.as = AGOK;
@@ -247,9 +226,6 @@ main(int argc, char *argv[])
 	buildop();
 	thumbbuildop();	// could build on demand
 	histgen = 0;
-	textp = P;
-	datap = P;
-	edatap = P;
 	pc = 0;
 	dtype = 4;
 	nuxiinit();
@@ -257,8 +233,6 @@ main(int argc, char *argv[])
 	version = 0;
 	cbp = buf.cbuf;
 	cbc = sizeof(buf.cbuf);
-	firstp = prg();
-	lastp = firstp;
 
 	addlibpath("command line", "command line", argv[0], "main");
 	loadlib();
@@ -268,52 +242,30 @@ main(int argc, char *argv[])
 	for(i=0; i<nelem(linkername); i++)
 		mark(lookup(linkername[i], 0));
 	deadcode();
-
-	firstp = firstp->link;
-	if(firstp == P)
-		goto out;
-	if(doexp || dlm){
-		EXPTAB = "_exporttab";
-		zerosig(EXPTAB);
-		zerosig("etext");
-		zerosig("edata");
-		zerosig("end");
-		if(dlm){
-			initdiv();
-			import();
-			HEADTYPE = 2;
-			INITTEXT = INITDAT = 0;
-			INITRND = 8;
-			INITENTRY = EXPTAB;
-		}
-		else
-			divsig();
-		export();
+	if(textp == nil) {
+		diag("no code");
+		errorexit();
 	}
+
 	patch();
 	if(debug['p'])
 		if(debug['1'])
 			doprof1();
 		else
 			doprof2();
-	if(debug['u'])
-		reachable();
 	doelf();
-	dodata();
-	if(seenthumb && debug['f'])
-		fnptrs();
 	follow();
-	if(firstp == P) {
-		diag("no code");
-		errorexit();
-	}
 	softfloat();
 	noops();
 	span();
+	pclntab();
+	symtab();
+	dodata();
+	address();
+	reloc();
 	asmb();
 	undef();
 
-out:
 	if(debug['c']){
 		thumbcount();
 		print("ARM size = %d\n", armsize);
@@ -327,7 +279,7 @@ out:
 	errorexit();
 }
 
-void
+static void
 zaddr(Biobuf *f, Adr *a, Sym *h[])
 {
 	int i, c;
@@ -355,7 +307,7 @@ zaddr(Biobuf *f, Adr *a, Sym *h[])
 	if(a->type == D_CONST || a->type == D_OCONST) {
 		if(a->name == D_EXTERN || a->name == D_STATIC) {
 			s = a->sym;
-			if(s != S && (s->type == STEXT || s->type == SLEAF || s->type == SCONST || s->type == SXREF)) {
+			if(s != S && (s->type == STEXT || s->type == SCONST || s->type == SXREF)) {
 				if(0 && !s->fnptr && s->name[0] != '.')
 					print("%s used as function pointer\n", s->name);
 				s->fnptr = 1;	// over the top cos of SXREF
@@ -398,9 +350,8 @@ zaddr(Biobuf *f, Adr *a, Sym *h[])
 		break;
 
 	case D_FCONST:
-		a->ieee = mal(sizeof(Ieee));
-		a->ieee->l = Bget4(f);
-		a->ieee->h = Bget4(f);
+		a->ieee.l = Bget4(f);
+		a->ieee.h = Bget4(f);
 		break;
 	}
 	s = a->sym;
@@ -441,7 +392,7 @@ void
 ldobj1(Biobuf *f, char *pkg, int64 len, char *pn)
 {
 	int32 ipc;
-	Prog *p, *t;
+	Prog *p;
 	Sym *h[NSYM], *s, *di;
 	int v, o, r, skip;
 	uint32 sig;
@@ -449,7 +400,9 @@ ldobj1(Biobuf *f, char *pkg, int64 len, char *pn)
 	int ntext;
 	int32 eof;
 	char src[1024], *x;
+	Prog *lastp;
 
+	lastp = nil;
 	ntext = 0;
 	eof = Boffset(f) + len;
 	di = S;
@@ -499,13 +452,17 @@ loop:
 
 		if(sig != 0){
 			if(s->sig != 0 && s->sig != sig)
-				diag("incompatible type signatures %lux(%s) and %lux(%s) for %s", s->sig, s->file, sig, pn, s->name);
+				diag("incompatible type signatures %ux(%s) and %ux(%s) for %s", s->sig, s->file, sig, pn, s->name);
 			s->sig = sig;
 			s->file = pn;
 		}
 
 		if(debug['W'])
 			print("	ANAME	%s\n", s->name);
+		if(o < 0 || o >= nelem(h)) {
+			fprint(2, "%s: mangled input file\n", pn);
+			errorexit();
+		}
 		h[o] = s;
 		if((v == D_EXTERN || v == D_STATIC) && s->type == 0)
 			s->type = SXREF;
@@ -533,8 +490,8 @@ loop:
 	zaddr(f, &p->from, h);
 	zaddr(f, &p->to, h);
 
-	if(p->reg > NREG)
-		diag("register out of range %d", p->reg);
+	if(p->as != ATEXT && p->as != AGLOBL && p->reg > NREG)
+		diag("register out of range %A %d", p->as, p->reg);
 
 	p->link = P;
 	p->cond = P;
@@ -559,10 +516,10 @@ loop:
 
 	case AEND:
 		histtoauto();
-		if(curtext != P)
-			curtext->to.autom = curauto;
+		if(cursym != nil && cursym->text)
+			cursym->autom = curauto;
 		curauto = 0;
-		curtext = P;
+		cursym = nil;
 		if(Boffset(f) == eof)
 			return;
 		goto newloop;
@@ -582,98 +539,31 @@ loop:
 			s->type = SBSS;
 			s->value = 0;
 		}
-		if(p->to.offset > s->value)
-			s->value = p->to.offset;
+		if(p->to.offset > s->size)
+			s->size = p->to.offset;
 		if(p->reg & DUPOK)
 			s->dupok = 1;
 		break;
 
-	case ADYNT:
-		s = p->from.sym;
-		if(p->to.sym == S) {
-			diag("DYNT without a sym\n%P", p);
-			break;
-		}
-		di = p->to.sym;
-		p->reg = 4;
-		if(di->type == SXREF) {
-			if(debug['z'])
-				Bprint(&bso, "%P set to %d\n", p, dtype);
-			di->type = SCONST;
-			di->value = dtype;
-			dtype += 4;
-		}
-		if(s == S)
-			break;
-
-		p->from.offset = di->value;
-		s->type = SDATA;
-		if(curtext == P) {
-			diag("DYNT not in text: %P", p);
-			break;
-		}
-		p->to.sym = curtext->from.sym;
-		p->to.type = D_CONST;
-		if(s != S) {
-			p->dlink = s->data;
-			s->data = p;
-		}
-		if(edatap == P)
-			datap = p;
-		else
-			edatap->link = p;
-		edatap = p;
-		break;
-
-	case AINIT:
-		s = p->from.sym;
-		if(s == S) {
-			diag("INIT without a sym\n%P", p);
-			break;
-		}
-		if(di == S) {
-			diag("INIT without previous DYNT\n%P", p);
-			break;
-		}
-		p->from.offset = di->value;
-		s->type = SDATA;
-		if(s != S) {
-			p->dlink = s->data;
-			s->data = p;
-		}
-		if(edatap == P)
-			datap = p;
-		else
-			edatap->link = p;
-		edatap = p;
-		break;
-
 	case ADATA:
 		// Assume that AGLOBL comes after ADATA.
 		// If we've seen an AGLOBL that said this sym was DUPOK,
 		// ignore any more ADATA we see, which must be
 		// redefinitions.
 		s = p->from.sym;
-		if(s != S && s->dupok) {
+		if(s->dupok) {
 			if(debug['v'])
 				Bprint(&bso, "skipping %s in %s: dupok\n", s->name, pn);
 			goto loop;
 		}
-		if(s != S) {
-			p->dlink = s->data;
-			s->data = p;
-			if(s->file == nil)
-				s->file = pn;
-			else if(s->file != pn) {
-				diag("multiple initialization for %s: in both %s and %s", s->name, s->file, pn);
-				errorexit();
-			}			
+		if(s->file == nil)
+			s->file = pn;
+		else if(s->file != pn) {
+			diag("multiple initialization for %s: in both %s and %s", s->name, s->file, pn);
+			errorexit();
 		}
-		if(edatap == P)
-			datap = p;
-		else
-			edatap->link = p;
-		edatap = p;
+		savedata(s, p);
+		unmal(p, sizeof *p);
 		break;
 
 	case AGOK:
@@ -683,31 +573,24 @@ loop:
 		break;
 
 	case ATEXT:
-		s = p->from.sym;
-		if(ntext++ == 0 && s->type != 0 && s->type != SXREF) {
-			/* redefinition, so file has probably been seen before */
-			if(debug['v'])
-				Bprint(&bso, "skipping: %s: redefinition: %s", pn, s->name);
-			return;
-		}
-		setarch(p);
-		setthumb(p);
-		p->align = 4;
-		if(curtext != P) {
+		if(cursym != nil && cursym->text) {
 			histtoauto();
-			curtext->to.autom = curauto;
+			cursym->autom = curauto;
 			curauto = 0;
 		}
-		skip = 0;
-		curtext = p;
-		autosize = (p->to.offset+3L) & ~3L;
-		p->to.offset = autosize;
-		autosize += 4;
 		s = p->from.sym;
 		if(s == S) {
 			diag("TEXT must have a name\n%P", p);
 			errorexit();
 		}
+		cursym = s;
+		if(ntext++ == 0 && s->type != 0 && s->type != SXREF) {
+			/* redefinition, so file has probably been seen before */
+			if(debug['v'])
+				Bprint(&bso, "skipping: %s: redefinition: %s", pn, s->name);
+			return;
+		}
+		skip = 0;
 		if(s->type != 0 && s->type != SXREF) {
 			if(p->reg & DUPOK) {
 				skip = 1;
@@ -715,21 +598,24 @@ loop:
 			}
 			diag("redefinition: %s\n%P", s->name, p);
 		}
+		if(etextp)
+			etextp->next = s;
+		else
+			textp = s;
+		etextp = s;
+		setarch(p);
+		setthumb(p);
+		p->align = 4;
+		autosize = (p->to.offset+3L) & ~3L;
+		p->to.offset = autosize;
+		autosize += 4;
 		s->type = STEXT;
 		s->text = p;
 		s->value = pc;
 		s->thumb = thumb;
-		lastp->link = p;
 		lastp = p;
 		p->pc = pc;
 		pc++;
-		if(textp == P) {
-			textp = p;
-			etextp = p;
-			goto loop;
-		}
-		etextp->cond = p;
-		etextp = p;
 		break;
 
 	case ASUB:
@@ -778,27 +664,15 @@ loop:
 		if(skip)
 			goto casedef;
 
-		if(p->from.type == D_FCONST && chipfloat(p->from.ieee) < 0) {
+		if(p->from.type == D_FCONST && chipfloat(&p->from.ieee) < 0 &&
+		   (chipzero(&p->from.ieee) < 0 || (p->scond & C_SCOND) != C_SCOND_NONE)) {
 			/* size sb 9 max */
-			sprint(literal, "$%lux", ieeedtof(p->from.ieee));
+			sprint(literal, "$%ux", ieeedtof(&p->from.ieee));
 			s = lookup(literal, 0);
 			if(s->type == 0) {
 				s->type = SBSS;
-				s->value = 4;
-				t = prg();
-				t->as = ADATA;
-				t->line = p->line;
-				t->from.type = D_OREG;
-				t->from.sym = s;
-				t->from.name = D_EXTERN;
-				t->reg = 4;
-				t->to = p->from;
-				if(edatap == P)
-					datap = t;
-				else
-					edatap->link = t;
-				edatap = t;
-				t->link = P;
+				adduint32(s, ieeedtof(&p->from.ieee));
+				s->reachable = 0;
 			}
 			p->from.type = D_OREG;
 			p->from.sym = s;
@@ -813,28 +687,17 @@ loop:
 		if(skip)
 			goto casedef;
 
-		if(p->from.type == D_FCONST && chipfloat(p->from.ieee) < 0) {
+		if(p->from.type == D_FCONST && chipfloat(&p->from.ieee) < 0 &&
+		   (chipzero(&p->from.ieee) < 0 || (p->scond & C_SCOND) != C_SCOND_NONE)) {
 			/* size sb 18 max */
-			sprint(literal, "$%lux.%lux",
-				p->from.ieee->l, p->from.ieee->h);
+			sprint(literal, "$%ux.%ux",
+				p->from.ieee.l, p->from.ieee.h);
 			s = lookup(literal, 0);
 			if(s->type == 0) {
 				s->type = SBSS;
-				s->value = 8;
-				t = prg();
-				t->as = ADATA;
-				t->line = p->line;
-				t->from.type = D_OREG;
-				t->from.sym = s;
-				t->from.name = D_EXTERN;
-				t->reg = 8;
-				t->to = p->from;
-				if(edatap == P)
-					datap = t;
-				else
-					edatap->link = t;
-				edatap = t;
-				t->link = P;
+				adduint32(s, p->from.ieee.l);
+				adduint32(s, p->from.ieee.h);
+				s->reachable = 0;
 			}
 			p->from.type = D_OREG;
 			p->from.sym = s;
@@ -847,13 +710,17 @@ loop:
 	casedef:
 		if(skip)
 			nopout(p);
-
+		p->pc = pc;
+		pc++;
 		if(p->to.type == D_BRANCH)
 			p->to.offset += ipc;
+		if(lastp == nil) {
+			if(p->as != ANOP)
+				diag("unexpected instruction: %P", p);
+			break;
+		}
 		lastp->link = p;
 		lastp = p;
-		p->pc = pc;
-		pc++;
 		break;
 	}
 	goto loop;
@@ -872,191 +739,13 @@ prg(void)
 	return p;
 }
 
-void
-doprof1(void)
-{
-	Sym *s;
-	int32 n;
-	Prog *p, *q;
-
-	if(debug['v'])
-		Bprint(&bso, "%5.2f profile 1\n", cputime());
-	Bflush(&bso);
-	s = lookup("__mcount", 0);
-	n = 1;
-	for(p = firstp->link; p != P; p = p->link) {
-		setarch(p);
-		if(p->as == ATEXT) {
-			q = prg();
-			q->line = p->line;
-			q->link = datap;
-			datap = q;
-			q->as = ADATA;
-			q->from.type = D_OREG;
-			q->from.name = D_EXTERN;
-			q->from.offset = n*4;
-			q->from.sym = s;
-			q->reg = 4;
-			q->to = p->from;
-			q->to.type = D_CONST;
-
-			q = prg();
-			q->line = p->line;
-			q->pc = p->pc;
-			q->link = p->link;
-			p->link = q;
-			p = q;
-			p->as = AMOVW;
-			p->from.type = D_OREG;
-			p->from.name = D_EXTERN;
-			p->from.sym = s;
-			p->from.offset = n*4 + 4;
-			p->to.type = D_REG;
-			p->to.reg = thumb ? REGTMPT : REGTMP;
-
-			q = prg();
-			q->line = p->line;
-			q->pc = p->pc;
-			q->link = p->link;
-			p->link = q;
-			p = q;
-			p->as = AADD;
-			p->from.type = D_CONST;
-			p->from.offset = 1;
-			p->to.type = D_REG;
-			p->to.reg = thumb ? REGTMPT : REGTMP;
-
-			q = prg();
-			q->line = p->line;
-			q->pc = p->pc;
-			q->link = p->link;
-			p->link = q;
-			p = q;
-			p->as = AMOVW;
-			p->from.type = D_REG;
-			p->from.reg = thumb ? REGTMPT : REGTMP;
-			p->to.type = D_OREG;
-			p->to.name = D_EXTERN;
-			p->to.sym = s;
-			p->to.offset = n*4 + 4;
-
-			n += 2;
-			continue;
-		}
-	}
-	q = prg();
-	q->line = 0;
-	q->link = datap;
-	datap = q;
-
-	q->as = ADATA;
-	q->from.type = D_OREG;
-	q->from.name = D_EXTERN;
-	q->from.sym = s;
-	q->reg = 4;
-	q->to.type = D_CONST;
-	q->to.offset = n;
-
-	s->type = SBSS;
-	s->value = n*4;
-}
-
-void
-doprof2(void)
-{
-	Sym *s2, *s4;
-	Prog *p, *q, *ps2, *ps4;
-
-	if(debug['v'])
-		Bprint(&bso, "%5.2f profile 2\n", cputime());
-	Bflush(&bso);
-	s2 = lookup("_profin", 0);
-	s4 = lookup("_profout", 0);
-	if(s2->type != STEXT || s4->type != STEXT) {
-		diag("_profin/_profout not defined");
-		return;
-	}
-	ps2 = P;
-	ps4 = P;
-	for(p = firstp; p != P; p = p->link) {
-		setarch(p);
-		if(p->as == ATEXT) {
-			if(p->from.sym == s2) {
-				ps2 = p;
-				p->reg = 1;
-			}
-			if(p->from.sym == s4) {
-				ps4 = p;
-				p->reg = 1;
-			}
-		}
-	}
-	for(p = firstp; p != P; p = p->link) {
-		setarch(p);
-		if(p->as == ATEXT) {
-			if(p->reg & NOPROF) {
-				for(;;) {
-					q = p->link;
-					if(q == P)
-						break;
-					if(q->as == ATEXT)
-						break;
-					p = q;
-				}
-				continue;
-			}
-
-			/*
-			 * BL	profin, R2
-			 */
-			q = prg();
-			q->line = p->line;
-			q->pc = p->pc;
-			q->link = p->link;
-			p->link = q;
-			p = q;
-			p->as = ABL;
-			p->to.type = D_BRANCH;
-			p->cond = ps2;
-			p->to.sym = s2;
-
-			continue;
-		}
-		if(p->as == ARET) {
-			/*
-			 * RET
-			 */
-			q = prg();
-			q->as = ARET;
-			q->from = p->from;
-			q->to = p->to;
-			q->link = p->link;
-			p->link = q;
-
-			/*
-			 * BL	profout
-			 */
-			p->as = ABL;
-			p->from = zprg.from;
-			p->to = zprg.to;
-			p->to.type = D_BRANCH;
-			p->cond = ps4;
-			p->to.sym = s4;
-
-			p = q;
-
-			continue;
-		}
-	}
-}
-
 static void
 puntfp(Prog *p)
 {
 	USED(p);
 	/* floating point - punt for now */
-	curtext->reg = NREG;	/* ARM */
-	curtext->from.sym->thumb = 0;
+	cursym->text->reg = NREG;	/* ARM */
+	cursym->thumb = 0;
 	thumb = 0;
 	// print("%s: generating ARM code (contains floating point ops %d)\n", curtext->from.sym->name, p->line);
 }
diff --git a/src/cmd/5l/optab.c b/src/cmd/5l/optab.c
index 92fe12fc2..96b216837 100644
--- a/src/cmd/5l/optab.c
+++ b/src/cmd/5l/optab.c
@@ -34,8 +34,6 @@ Optab	optab[] =
 {
 	/* struct Optab:
 	  OPCODE,	from, prog->reg, to,		 type,size,param,flag */
-	{ ATEXT,	C_LEXT,	C_NONE,	C_LCON, 	 0, 0, 0 },
-	{ ATEXT,	C_LEXT,	C_REG,	C_LCON, 	 0, 0, 0 },
 	{ ATEXT,	C_ADDR,	C_NONE,	C_LCON, 	 0, 0, 0 },
 	{ ATEXT,	C_ADDR,	C_REG,	C_LCON, 	 0, 0, 0 },
 
@@ -56,7 +54,6 @@ Optab	optab[] =
 	{ AMVN,		C_SHIFT,C_NONE,	C_REG,		 3, 4, 0 },
 	{ ACMP,		C_SHIFT,C_REG,	C_NONE,		 3, 4, 0 },
 
-	{ AMOVW,	C_RECON,C_NONE,	C_REG,		 4, 4, REGSB },
 	{ AMOVW,	C_RACON,C_NONE,	C_REG,		 4, 4, REGSP },
 
 	{ AB,		C_NONE,	C_NONE,	C_SBRA,		 5, 4, 0,	LPOOL },
@@ -81,7 +78,6 @@ Optab	optab[] =
 
 	{ AWORD,	C_NONE,	C_NONE,	C_LCON,		11, 4, 0 },
 	{ AWORD,	C_NONE,	C_NONE,	C_GCON,		11, 4, 0 },
-	{ AWORD,	C_NONE,	C_NONE,	C_LEXT,		11, 4, 0 },
 	{ AWORD,	C_NONE,	C_NONE,	C_ADDR,		11, 4, 0 },
 
 	{ AMOVW,	C_NCON,	C_NONE,	C_REG,		12, 4, 0 },
@@ -109,85 +105,64 @@ Optab	optab[] =
 
 	{ AMULL,	C_REG,	C_REG,	C_REGREG,	17, 4, 0 },
 
-	{ AMOVW,	C_REG,	C_NONE,	C_SEXT,		20, 4, REGSB },
 	{ AMOVW,	C_REG,	C_NONE,	C_SAUTO,	20, 4, REGSP },
 	{ AMOVW,	C_REG,	C_NONE,	C_SOREG,	20, 4, 0 },
-	{ AMOVB,	C_REG,	C_NONE,	C_SEXT,		20, 4, REGSB },
 	{ AMOVB,	C_REG,	C_NONE,	C_SAUTO,	20, 4, REGSP },
 	{ AMOVB,	C_REG,	C_NONE,	C_SOREG,	20, 4, 0 },
-	{ AMOVBU,	C_REG,	C_NONE,	C_SEXT,		20, 4, REGSB },
 	{ AMOVBU,	C_REG,	C_NONE,	C_SAUTO,	20, 4, REGSP },
 	{ AMOVBU,	C_REG,	C_NONE,	C_SOREG,	20, 4, 0 },
 
-	{ AMOVW,	C_SEXT,	C_NONE,	C_REG,		21, 4, REGSB },
 	{ AMOVW,	C_SAUTO,C_NONE,	C_REG,		21, 4, REGSP },
 	{ AMOVW,	C_SOREG,C_NONE,	C_REG,		21, 4, 0 },
-	{ AMOVBU,	C_SEXT,	C_NONE,	C_REG,		21, 4, REGSB },
 	{ AMOVBU,	C_SAUTO,C_NONE,	C_REG,		21, 4, REGSP },
 	{ AMOVBU,	C_SOREG,C_NONE,	C_REG,		21, 4, 0 },
 
-	{ AMOVB,	C_SEXT,	C_NONE,	C_REG,		22, 12, REGSB },
 	{ AMOVB,	C_SAUTO,C_NONE,	C_REG,		22, 12, REGSP },
 	{ AMOVB,	C_SOREG,C_NONE,	C_REG,		22, 12, 0 },
-	{ AMOVH,	C_SEXT,	C_NONE,	C_REG,		22, 12, REGSB },
 	{ AMOVH,	C_SAUTO,C_NONE,	C_REG,		22, 12, REGSP },
 	{ AMOVH,	C_SOREG,C_NONE,	C_REG,		22, 12, 0 },
-	{ AMOVHU,	C_SEXT,	C_NONE,	C_REG,		22, 12, REGSB },
 	{ AMOVHU,	C_SAUTO,C_NONE,	C_REG,		22, 12, REGSP },
 	{ AMOVHU,	C_SOREG,C_NONE,	C_REG,		22, 12, 0 },
 
-	{ AMOVH,	C_REG,	C_NONE,	C_SEXT,		23, 12, REGSB },
 	{ AMOVH,	C_REG,	C_NONE,	C_SAUTO,	23, 12, REGSP },
 	{ AMOVH,	C_REG,	C_NONE,	C_SOREG,	23, 12, 0 },
-	{ AMOVHU,	C_REG,	C_NONE,	C_SEXT,		23, 12, REGSB },
 	{ AMOVHU,	C_REG,	C_NONE,	C_SAUTO,	23, 12, REGSP },
 	{ AMOVHU,	C_REG,	C_NONE,	C_SOREG,	23, 12, 0 },
 
-	{ AMOVW,	C_REG,	C_NONE,	C_LEXT,		30, 8, REGSB,	LTO },
 	{ AMOVW,	C_REG,	C_NONE,	C_LAUTO,	30, 8, REGSP,	LTO },
 	{ AMOVW,	C_REG,	C_NONE,	C_LOREG,	30, 8, 0,	LTO },
 	{ AMOVW,	C_REG,	C_NONE,	C_ADDR,		64, 8, 0,	LTO },
-	{ AMOVB,	C_REG,	C_NONE,	C_LEXT,		30, 8, REGSB,	LTO },
 	{ AMOVB,	C_REG,	C_NONE,	C_LAUTO,	30, 8, REGSP,	LTO },
 	{ AMOVB,	C_REG,	C_NONE,	C_LOREG,	30, 8, 0,	LTO },
 	{ AMOVB,	C_REG,	C_NONE,	C_ADDR,		64, 8, 0,	LTO },
-	{ AMOVBU,	C_REG,	C_NONE,	C_LEXT,		30, 8, REGSB,	LTO },
 	{ AMOVBU,	C_REG,	C_NONE,	C_LAUTO,	30, 8, REGSP,	LTO },
 	{ AMOVBU,	C_REG,	C_NONE,	C_LOREG,	30, 8, 0,	LTO },
 	{ AMOVBU,	C_REG,	C_NONE,	C_ADDR,		64, 8, 0,	LTO },
 
-	{ AMOVW,	C_LEXT,	C_NONE,	C_REG,		31, 8, REGSB,	LFROM },
 	{ AMOVW,	C_LAUTO,C_NONE,	C_REG,		31, 8, REGSP,	LFROM },
 	{ AMOVW,	C_LOREG,C_NONE,	C_REG,		31, 8, 0,	LFROM },
 	{ AMOVW,	C_ADDR,	C_NONE,	C_REG,		65, 8, 0,	LFROM },
-	{ AMOVBU,	C_LEXT,	C_NONE,	C_REG,		31, 8, REGSB,	LFROM },
 	{ AMOVBU,	C_LAUTO,C_NONE,	C_REG,		31, 8, REGSP,	LFROM },
 	{ AMOVBU,	C_LOREG,C_NONE,	C_REG,		31, 8, 0,	LFROM },
 	{ AMOVBU,	C_ADDR,	C_NONE,	C_REG,		65, 8, 0,	LFROM },
 
-	{ AMOVB,	C_LEXT,	C_NONE,	C_REG,		32, 16, REGSB,	LFROM },
 	{ AMOVB,	C_LAUTO,C_NONE,	C_REG,		32, 16, REGSP,	LFROM },
 	{ AMOVB,	C_LOREG,C_NONE,	C_REG,		32, 16, 0,	LFROM },
 	{ AMOVB,	C_ADDR,	C_NONE,	C_REG,		66, 16, 0,	LFROM },
-	{ AMOVH,	C_LEXT,	C_NONE,	C_REG,		32, 16, REGSB,	LFROM },
 	{ AMOVH,	C_LAUTO,C_NONE,	C_REG,		32, 16, REGSP,	LFROM },
 	{ AMOVH,	C_LOREG,C_NONE,	C_REG,		32, 16, 0,	LFROM },
 	{ AMOVH,	C_ADDR,	C_NONE,	C_REG,		66, 16, 0,	LFROM },
-	{ AMOVHU,	C_LEXT,	C_NONE,	C_REG,		32, 16, REGSB,	LFROM },
 	{ AMOVHU,	C_LAUTO,C_NONE,	C_REG,		32, 16, REGSP,	LFROM },
 	{ AMOVHU,	C_LOREG,C_NONE,	C_REG,		32, 16, 0,	LFROM },
 	{ AMOVHU,	C_ADDR,	C_NONE,	C_REG,		66, 16, 0,	LFROM },
 
-	{ AMOVH,	C_REG,	C_NONE,	C_LEXT,		33, 24, REGSB,	LTO },
 	{ AMOVH,	C_REG,	C_NONE,	C_LAUTO,	33, 24, REGSP,	LTO },
 	{ AMOVH,	C_REG,	C_NONE,	C_LOREG,	33, 24, 0,	LTO },
 	{ AMOVH,	C_REG,	C_NONE,	C_ADDR,		67, 24, 0,	LTO },
-	{ AMOVHU,	C_REG,	C_NONE,	C_LEXT,		33, 24, REGSB,	LTO },
 	{ AMOVHU,	C_REG,	C_NONE,	C_LAUTO,	33, 24, REGSP,	LTO },
 	{ AMOVHU,	C_REG,	C_NONE,	C_LOREG,	33, 24, 0,	LTO },
 	{ AMOVHU,	C_REG,	C_NONE,	C_ADDR,		67, 24, 0,	LTO },
 
-	{ AMOVW,	C_LECON,C_NONE,	C_REG,		34, 8, REGSB,	LFROM },
 	{ AMOVW,	C_LACON,C_NONE,	C_REG,		34, 8, REGSP,	LFROM },
 
 	{ AMOVW,	C_PSR,	C_NONE,	C_REG,		35, 4, 0 },
@@ -201,19 +176,15 @@ Optab	optab[] =
 
 	{ ARFE,		C_NONE,	C_NONE,	C_NONE,		41, 4, 0 },
 
-	{ AMOVF,	C_FREG,	C_NONE,	C_FEXT,		50, 4, REGSB },
 	{ AMOVF,	C_FREG,	C_NONE,	C_FAUTO,	50, 4, REGSP },
 	{ AMOVF,	C_FREG,	C_NONE,	C_FOREG,	50, 4, 0 },
 
-	{ AMOVF,	C_FEXT,	C_NONE,	C_FREG,		51, 4, REGSB },
 	{ AMOVF,	C_FAUTO,C_NONE,	C_FREG,		51, 4, REGSP },
 	{ AMOVF,	C_FOREG,C_NONE,	C_FREG,		51, 4, 0 },
 
-	{ AMOVF,	C_FREG,	C_NONE,	C_LEXT,		52, 12, REGSB,	LTO },
 	{ AMOVF,	C_FREG,	C_NONE,	C_LAUTO,	52, 12, REGSP,	LTO },
 	{ AMOVF,	C_FREG,	C_NONE,	C_LOREG,	52, 12, 0,	LTO },
 
-	{ AMOVF,	C_LEXT,	C_NONE,	C_FREG,		53, 12, REGSB,	LFROM },
 	{ AMOVF,	C_LAUTO,C_NONE,	C_FREG,		53, 12, REGSP,	LFROM },
 	{ AMOVF,	C_LOREG,C_NONE,	C_FREG,		53, 12, 0,	LFROM },
 
@@ -222,17 +193,8 @@ Optab	optab[] =
 
 	{ AADDF,	C_FREG,	C_NONE,	C_FREG,		54, 4, 0 },
 	{ AADDF,	C_FREG,	C_REG,	C_FREG,		54, 4, 0 },
-	{ AADDF,	C_FCON,	C_NONE,	C_FREG,		54, 4, 0 },
-	{ AADDF,	C_FCON,	C_REG,	C_FREG,		54, 4, 0 },
-	{ AMOVF,	C_FCON,	C_NONE,	C_FREG,		54, 4, 0 },
 	{ AMOVF,	C_FREG, C_NONE, C_FREG,		54, 4, 0 },
 
-	{ ACMPF,	C_FREG,	C_REG,	C_NONE,		54, 4, 0 },
-	{ ACMPF,	C_FCON,	C_REG,	C_NONE,		54, 4, 0 },
-
-	{ AMOVFW,	C_FREG,	C_NONE,	C_REG,		55, 4, 0 },
-	{ AMOVFW,	C_REG,	C_NONE,	C_FREG,		55, 4, 0 },
-
 	{ AMOVW,	C_REG,	C_NONE,	C_FCR,		56, 4, 0 },
 	{ AMOVW,	C_FCR,	C_NONE,	C_REG,		57, 4, 0 },
 
@@ -248,41 +210,46 @@ Optab	optab[] =
 	{ ACASE,	C_REG,	C_NONE,	C_NONE,		62, 4, 0 },
 	{ ABCASE,	C_NONE, C_NONE, C_SBRA,		63, 4, 0 },
 
-	{ AMOVH,	C_REG,	C_NONE,	C_HEXT,		70, 4, REGSB,	V4 },
 	{ AMOVH,	C_REG,	C_NONE, C_HAUTO,	70, 4, REGSP,	V4 },
 	{ AMOVH,	C_REG,	C_NONE,	C_HOREG,	70, 4, 0,	V4 },
-	{ AMOVHU,	C_REG,	C_NONE,	C_HEXT,		70, 4, REGSB,	V4 },
 	{ AMOVHU,	C_REG,	C_NONE, C_HAUTO,	70, 4, REGSP,	V4 },
 	{ AMOVHU,	C_REG,	C_NONE,	C_HOREG,	70, 4, 0,	V4 },
 
-	{ AMOVB,	C_HEXT,	C_NONE, C_REG,		71, 4, REGSB,	V4 },
 	{ AMOVB,	C_HAUTO,C_NONE,	C_REG,		71, 4, REGSP,	V4 },
 	{ AMOVB,	C_HOREG,C_NONE,	C_REG,		71, 4, 0,	V4 },
-	{ AMOVH,	C_HEXT,	C_NONE,	C_REG,		71, 4, REGSB,	V4 },
 	{ AMOVH,	C_HAUTO,C_NONE, C_REG,		71, 4, REGSP,	V4 },
 	{ AMOVH,	C_HOREG,C_NONE,	C_REG,		71, 4, 0,	V4 },
-	{ AMOVHU,	C_HEXT,	C_NONE,	C_REG,		71, 4, REGSB,	V4 },
 	{ AMOVHU,	C_HAUTO,C_NONE, C_REG,		71, 4, REGSP,	V4 },
 	{ AMOVHU,	C_HOREG,C_NONE,	C_REG,		71, 4, 0,	V4 },
 
-	{ AMOVH,	C_REG,	C_NONE,	C_LEXT,		72, 8, REGSB,	LTO|V4 },
 	{ AMOVH,	C_REG,	C_NONE, C_LAUTO,	72, 8, REGSP,	LTO|V4 },
 	{ AMOVH,	C_REG,	C_NONE,	C_LOREG,	72, 8, 0,	LTO|V4 },
-	{ AMOVHU,	C_REG,	C_NONE,	C_LEXT,		72, 8, REGSB,	LTO|V4 },
 	{ AMOVHU,	C_REG,	C_NONE, C_LAUTO,	72, 8, REGSP,	LTO|V4 },
 	{ AMOVHU,	C_REG,	C_NONE,	C_LOREG,	72, 8, 0,	LTO|V4 },
 
-	{ AMOVB,	C_LEXT,	C_NONE, C_REG,		73, 8, REGSB,	LFROM|V4 },
 	{ AMOVB,	C_LAUTO,C_NONE,	C_REG,		73, 8, REGSP,	LFROM|V4 },
 	{ AMOVB,	C_LOREG,C_NONE,	C_REG,		73, 8, 0,	LFROM|V4 },
-	{ AMOVH,	C_LEXT,	C_NONE,	C_REG,		73, 8, REGSB,	LFROM|V4 },
 	{ AMOVH,	C_LAUTO,C_NONE, C_REG,		73, 8, REGSP,	LFROM|V4 },
 	{ AMOVH,	C_LOREG,C_NONE,	C_REG,		73, 8, 0,	LFROM|V4 },
-	{ AMOVHU,	C_LEXT,	C_NONE,	C_REG,		73, 8, REGSB,	LFROM|V4 },
 	{ AMOVHU,	C_LAUTO,C_NONE, C_REG,		73, 8, REGSP,	LFROM|V4 },
 	{ AMOVHU,	C_LOREG,C_NONE,	C_REG,		73, 8, 0,	LFROM|V4 },
 	{ ALDREX,	C_SOREG,C_NONE,	C_REG,		77, 4, 0 },
 	{ ASTREX,	C_SOREG,C_REG,	C_REG,		78, 4, 0 },
 
+	{ AMOVF,	C_ZFCON,C_NONE,	C_FREG,		80, 4, 0 },
+	{ AMOVF,	C_SFCON,C_NONE,	C_FREG,		81, 4, 0 },
+
+	{ ACMPF,	C_FREG,	C_REG,	C_NONE,		82, 8, 0 },
+	{ ACMPF,	C_FREG, C_NONE,	C_NONE,		83, 8, 0 },
+
+	{ AMOVFW,	C_FREG,	C_NONE,	C_FREG,		84, 4, 0 },
+	{ AMOVWF,	C_FREG,	C_NONE,	C_FREG,		85, 4, 0 },
+
+	{ AMOVFW,	C_FREG,	C_NONE,	C_REG,		86, 8, 0 },
+	{ AMOVWF,	C_REG,	C_NONE,	C_FREG,		87, 8, 0 },
+
+	{ AMOVW,	C_REG,	C_NONE,	C_FREG,		88, 4, 0 },
+	{ AMOVW,	C_FREG,	C_NONE,	C_REG,		89, 4, 0 },
+
 	{ AXXX,		C_NONE,	C_NONE,	C_NONE,		 0, 4, 0 },
 };
diff --git a/src/cmd/5l/pass.c b/src/cmd/5l/pass.c
index 06b1792b4..e16b34171 100644
--- a/src/cmd/5l/pass.c
+++ b/src/cmd/5l/pass.c
@@ -28,147 +28,12 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+// Code and data passes.
+
 #include	"l.h"
 #include	"../ld/lib.h"
 
-void
-dodata(void)
-{
-	int i, t;
-	Sym *s;
-	Prog *p;
-	int32 orig, v;
-
-	if(debug['v'])
-		Bprint(&bso, "%5.2f dodata\n", cputime());
-	Bflush(&bso);
-	for(p = datap; p != P; p = p->link) {
-		s = p->from.sym;
-		if(p->as == ADYNT || p->as == AINIT)
-			s->value = dtype;
-		if(s->type == SBSS)
-			s->type = SDATA;
-		if(s->type != SDATA && s->type != SELFDATA)
-			diag("initialize non-data (%d): %s\n%P",
-				s->type, s->name, p);
-		v = p->from.offset + p->reg;
-		if(v > s->value)
-			diag("initialize bounds (%ld/%ld): %s\n%P",
-				v, s->value, s->name, p);
-		if((s->type == SBSS || s->type == SDATA) && (p->to.type == D_CONST || p->to.type == D_OCONST) && (p->to.name == D_EXTERN || p->to.name == D_STATIC)){
-			s = p->to.sym;
-			if(s != S && (s->type == STEXT || s->type == SLEAF || s->type == SCONST || s->type == SXREF))
-				s->fnptr = 1;
-		}
-	}
-
-	if(debug['t']) {
-		/*
-		 * pull out string constants
-		 */
-		for(p = datap; p != P; p = p->link) {
-			s = p->from.sym;
-			if(p->to.type == D_SCONST)
-				s->type = SSTRING;
-		}
-	}
-	
-	/*
-	 * pass 0
-	 * assign elf data - must be segregated from real data
-	 */
-	orig = 0;
-	for(i=0; i<NHASH; i++)
-	for(s = hash[i]; s != S; s = s->link) {
-		if(!s->reachable || s->type != SELFDATA)
-			continue;
-		v = s->value;
-		while(v & 3)
-			v++;
-		s->size = v;
-		s->value = orig;
-		orig += v;
-	}
-	elfdatsize = orig;
-
-	/*
-	 * pass 1
-	 *	assign 'small' variables to data segment
-	 *	(rational is that data segment is more easily
-	 *	 addressed through offset on R12)
-	 */
-	for(i=0; i<NHASH; i++)
-	for(s = hash[i]; s != S; s = s->link) {
-		t = s->type;
-		if(t != SDATA && t != SBSS)
-			continue;
-		v = s->value;
-		if(v == 0) {
-			diag("%s: no size", s->name);
-			v = 1;
-		}
-		while(v & 3)
-			v++;
-		s->size = v;
-		s->value = v;
-		if(v > MINSIZ)
-			continue;
-		s->value = orig;
-		orig += v;
-		s->type = SDATA1;
-	}
-
-	/*
-	 * pass 2
-	 *	assign large 'data' variables to data segment
-	 */
-	for(i=0; i<NHASH; i++)
-	for(s = hash[i]; s != S; s = s->link) {
-		t = s->type;
-		if(t != SDATA) {
-			if(t == SDATA1)
-				s->type = SDATA;
-			continue;
-		}
-		v = s->value;
-		s->size = v;
-		s->value = orig;
-		orig += v;
-	}
-
-	while(orig & 7)
-		orig++;
-	datsize = orig;
-
-	/*
-	 * pass 3
-	 *	everything else to bss segment
-	 */
-	for(i=0; i<NHASH; i++)
-	for(s = hash[i]; s != S; s = s->link) {
-		if(s->type != SBSS)
-			continue;
-		v = s->value;
-		s->size = v;
-		s->value = orig;
-		orig += v;
-	}
-	while(orig & 7)
-		orig++;
-	bsssize = orig-datsize;
-
-	xdefine("setR12", SDATA, 0L+BIG);
-	xdefine("bdata", SDATA, 0L);
-	xdefine("data", SBSS, 0);
-	xdefine("edata", SDATA, datsize);
-	xdefine("end", SBSS, datsize+bsssize);
-	xdefine("etext", STEXT, 0L);
-
-	if(debug['s'])
-		xdefine("symdat", SFIXED, 0);
-	else
-		xdefine("symdat", SFIXED, SYMDATVA);
-}
+static void xfol(Prog*, Prog**);
 
 void
 undef(void)
@@ -177,7 +42,7 @@ undef(void)
 	Sym *s;
 
 	for(i=0; i<NHASH; i++)
-	for(s = hash[i]; s != S; s = s->link)
+	for(s = hash[i]; s != S; s = s->hash)
 		if(s->type == SXREF)
 			diag("%s: not defined", s->name);
 }
@@ -223,20 +88,23 @@ relinv(int a)
 void
 follow(void)
 {
+	Prog *firstp, *lastp;
+
 	if(debug['v'])
 		Bprint(&bso, "%5.2f follow\n", cputime());
 	Bflush(&bso);
 
-	firstp = prg();
-	lastp = firstp;
-	xfol(textp);
-
-	firstp = firstp->link;
-	lastp->link = P;
+	for(cursym = textp; cursym != nil; cursym = cursym->next) {
+		firstp = prg();
+		lastp = firstp;
+		xfol(cursym->text, &lastp);
+		lastp->link = nil;
+		cursym->text = firstp->link;
+	}
 }
 
-void
-xfol(Prog *p)
+static void
+xfol(Prog *p, Prog **last)
 {
 	Prog *q, *r;
 	int a, i;
@@ -246,12 +114,6 @@ loop:
 		return;
 	setarch(p);
 	a = p->as;
-	if(a == ATEXT)
-		curtext = p;
-	if(!curtext->from.sym->reachable) {
-		p = p->cond;
-		goto loop;
-	}
 	if(a == AB) {
 		q = p->cond;
 		if(q != P && q->as != ATEXT) {
@@ -263,7 +125,7 @@ loop:
 	}
 	if(p->mark & FOLL) {
 		for(i=0,q=p; i<4; i++,q=q->link) {
-			if(q == lastp)
+			if(q == *last || q == nil)
 				break;
 			a = q->as;
 			if(a == ANOP) {
@@ -272,7 +134,7 @@ loop:
 			}
 			if(a == AB || (a == ARET && q->scond == 14) || a == ARFE)
 				goto copy;
-			if(!q->cond || (q->cond->mark&FOLL))
+			if(q->cond == P || (q->cond->mark&FOLL))
 				continue;
 			if(a != ABEQ && a != ABNE)
 				continue;
@@ -285,12 +147,12 @@ loop:
 				r->mark |= FOLL;
 				if(p != q) {
 					p = p->link;
-					lastp->link = r;
-					lastp = r;
+					(*last)->link = r;
+					*last = r;
 					continue;
 				}
-				lastp->link = r;
-				lastp = r;
+				(*last)->link = r;
+				*last = r;
 				if(a == AB || (a == ARET && q->scond == 14) || a == ARFE)
 					return;
 				r->as = ABNE;
@@ -299,7 +161,7 @@ loop:
 				r->cond = p->link;
 				r->link = p->cond;
 				if(!(r->link->mark&FOLL))
-					xfol(r->link);
+					xfol(r->link, last);
 				if(!(r->cond->mark&FOLL))
 					print("cant happen 2\n");
 				return;
@@ -315,8 +177,8 @@ loop:
 		p = q;
 	}
 	p->mark |= FOLL;
-	lastp->link = p;
-	lastp = p;
+	(*last)->link = p;
+	*last = p;
 	if(a == AB || (a == ARET && p->scond == 14) || a == ARFE){
 		return;
 	}
@@ -329,7 +191,7 @@ loop:
 			p->link = p->cond;
 			p->cond = q;
 		}
-		xfol(p->link);
+		xfol(p->link, last);
 		q = brchain(p->cond);
 		if(q == P)
 			q = p->cond;
@@ -349,7 +211,7 @@ patch(void)
 {
 	int32 c, vexit;
 	Prog *p, *q;
-	Sym *s, *s1;
+	Sym *s;
 	int a;
 
 	if(debug['v'])
@@ -358,113 +220,71 @@ patch(void)
 	mkfwd();
 	s = lookup("exit", 0);
 	vexit = s->value;
-	for(p = firstp; p != P; p = p->link) {
-		setarch(p);
-		a = p->as;
-		if(a == ATEXT)
-			curtext = p;
-		if(seenthumb && a == ABL){
-			// if((s = p->to.sym) != S && (s1 = curtext->from.sym) != S)
-			//	print("%s calls %s\n", s1->name, s->name);
-			 if((s = p->to.sym) != S && (s1 = curtext->from.sym) != S && s->thumb != s1->thumb)
-				s->foreign = 1;
-		}
-		if((a == ABL || a == ABX || a == AB || a == ARET) &&
-		   p->to.type != D_BRANCH && p->to.sym != S) {
-			s = p->to.sym;
-			switch(s->type) {
-			default:
-				diag("undefined: %s", s->name);
-				s->type = STEXT;
-				s->value = vexit;
-				continue;	// avoid more error messages
-			case STEXT:
-				p->to.offset = s->value;
-				p->to.type = D_BRANCH;
-				break;
-			case SUNDEF:
-				if(p->as != ABL)
-					diag("help: SUNDEF in AB || ARET");
-				p->to.offset = 0;
-				p->to.type = D_BRANCH;
-				p->cond = UP;
-				break;
+	for(cursym = textp; cursym != nil; cursym = cursym->next) {
+		for(p = cursym->text; p != P; p = p->link) {
+			setarch(p);
+			a = p->as;
+			if(seenthumb && a == ABL){
+				// if((s = p->to.sym) != S && (s1 = curtext->from.sym) != S)
+				//	print("%s calls %s\n", s1->name, s->name);
+				 if((s = p->to.sym) != S && s->thumb != cursym->thumb)
+					s->foreign = 1;
 			}
-		}
-		if(p->to.type != D_BRANCH || p->cond == UP)
-			continue;
-		c = p->to.offset;
-		for(q = firstp; q != P;) {
-			if(q->forwd != P)
-			if(c >= q->forwd->pc) {
-				q = q->forwd;
+			if((a == ABL || a == ABX || a == AB || a == ARET) &&
+			   p->to.type != D_BRANCH && p->to.sym != S) {
+				s = p->to.sym;
+				switch(s->type) {
+				default:
+					diag("undefined: %s", s->name);
+					s->type = STEXT;
+					s->value = vexit;
+					continue;	// avoid more error messages
+				case STEXT:
+					p->to.offset = s->value;
+					p->to.type = D_BRANCH;
+					break;
+				}
+			}
+			if(p->to.type != D_BRANCH)
 				continue;
+			c = p->to.offset;
+			for(q = textp->text; q != P;) {
+				if(c == q->pc)
+					break;
+				if(q->forwd != P && c >= q->forwd->pc)
+					q = q->forwd;
+				else
+					q = q->link;
 			}
-			if(c == q->pc)
-				break;
-			q = q->link;
-		}
-		if(q == P) {
-			diag("branch out of range %ld\n%P", c, p);
-			p->to.type = D_NONE;
+			if(q == P) {
+				diag("branch out of range %d\n%P", c, p);
+				p->to.type = D_NONE;
+			}
+			p->cond = q;
 		}
-		p->cond = q;
 	}
 
-	for(p = firstp; p != P; p = p->link) {
-		setarch(p);
-		a = p->as;
-		if(p->as == ATEXT)
-			curtext = p;
-		if(seenthumb && a == ABL) {
+	for(cursym = textp; cursym != nil; cursym = cursym->next) {
+		for(p = cursym->text; p != P; p = p->link) {
+			setarch(p);
+			a = p->as;
+			if(seenthumb && a == ABL) {
 #ifdef CALLEEBX
-			if(0)
-				{}
+				if(0)
+					{}
 #else
-			if((s = p->to.sym) != S && (s->foreign || s->fnptr))
-				p->as = ABX;
+				if((s = p->to.sym) != S && (s->foreign || s->fnptr))
+					p->as = ABX;
 #endif
-			else if(p->to.type == D_OREG)
-				p->as = ABX;
-		}
-		if(p->cond != P && p->cond != UP) {
-			p->cond = brloop(p->cond);
-			if(p->cond != P)
-			if(p->to.type == D_BRANCH)
-				p->to.offset = p->cond->pc;
-		}
-	}
-}
-
-#define	LOG	5
-void
-mkfwd(void)
-{
-	Prog *p;
-	int32 dwn[LOG], cnt[LOG], i;
-	Prog *lst[LOG];
-
-	for(i=0; i<LOG; i++) {
-		if(i == 0)
-			cnt[i] = 1; else
-			cnt[i] = LOG * cnt[i-1];
-		dwn[i] = 1;
-		lst[i] = P;
-	}
-	i = 0;
-	for(p = firstp; p != P; p = p->link) {
-		if(p->as == ATEXT)
-			curtext = p;
-		i--;
-		if(i < 0)
-			i = LOG-1;
-		p->forwd = P;
-		dwn[i]--;
-		if(dwn[i] <= 0) {
-			dwn[i] = cnt[i];
-			if(lst[i] != P)
-				lst[i]->forwd = p;
-			lst[i] = p;
+				else if(p->to.type == D_OREG)
+					p->as = ABX;
+			}
+			if(p->cond != P) {
+				p->cond = brloop(p->cond);
+				if(p->cond != P)
+				if(p->to.type == D_BRANCH)
+					p->to.offset = p->cond->pc;
+			}
 		}
 	}
 }
@@ -543,462 +363,3 @@ rnd(int32 v, int32 r)
 	v -= c;
 	return v;
 }
-
-#define Reachable(n)	if((s = lookup(n, 0)) != nil) s->used++
-
-static void
-rused(Adr *a)
-{
-	Sym *s = a->sym;
-
-	if(s == S)
-		return;
-	if(a->type == D_OREG || a->type == D_OCONST || a->type == D_CONST){
-		if(a->name == D_EXTERN || a->name == D_STATIC){
-			if(s->used == 0)
-				s->used = 1;
-		}
-	}
-	else if(a->type == D_BRANCH){
-		if(s->used == 0)
-			s->used = 1;
-	}
-}
-
-void
-reachable()
-{
-	Prog *p, *prev, *prevt, *nextt, *q;
-	Sym *s, *s0;
-	int i, todo;
-	char *a;
-
-	Reachable("_div");
-	Reachable("_divu");
-	Reachable("_mod");
-	Reachable("_modu");
-	a = INITENTRY;
-	if(*a >= '0' && *a <= '9')
-		return;
-	s = lookup(a, 0);
-	if(s == nil)
-		return;
-	if(s->type == 0){
-		s->used = 1;	// to stop asm complaining
-		for(p = firstp; p != P && p->as != ATEXT; p = p->link)
-			;
-		if(p == nil)
-			return;
-		s = p->from.sym;
-	}
-	s->used = 1;
-	do{
-		todo = 0;
-		for(p = firstp; p != P; p = p->link){
-			if(p->as == ATEXT && (s0 = p->from.sym)->used == 1){
-				todo = 1;
-				for(q = p->link; q != P && q->as != ATEXT; q = q->link){
-					rused(&q->from);
-					rused(&q->to);
-				}
-				s0->used = 2;
-			}
-		}
-		for(p = datap; p != P; p = p->link){
-			if((s0 = p->from.sym)->used == 1){
-				todo = 1;
-				for(q = p; q != P; q = q->link){	// data can be scattered
-					if(q->from.sym == s0)
-						rused(&q->to);
-				}
-				s0->used = 2;
-			}
-		}
-	}while(todo);
-	prev = nil;
-	prevt = nextt = nil;
-	for(p = firstp; p != P; ){
-		if(p->as == ATEXT){
-			prevt = nextt;
-			nextt = p;
-		}
-		if(p->as == ATEXT && (s0 = p->from.sym)->used == 0){
-			s0->type = SREMOVED;
-			for(q = p->link; q != P && q->as != ATEXT; q = q->link)
-				;
-			if(q != p->cond)
-				diag("bad ptr in reachable()");
-			if(prev == nil)
-				firstp = q;
-			else
-				prev->link = q;
-			if(q == nil)
-				lastp = prev;
-			if(prevt == nil)
-				textp = q;
-			else
-				prevt->cond = q;
-			if(q == nil)
-				etextp = prevt;
-			nextt = prevt;
-			if(debug['V'])
-				print("%s unused\n", s0->name);
-			p = q;
-		}
-		else{
-			prev = p;
-			p = p->link;
-		}
-	}
-	prevt = nil;
-	for(p = datap; p != nil; ){
-		if((s0 = p->from.sym)->used == 0){
-			s0->type = SREMOVED;
-			prev = prevt;
-			for(q = p; q != nil; q = q->link){
-				if(q->from.sym == s0){
-					if(prev == nil)
-						datap = q->link;
-					else
-						prev->link = q->link;
-				}
-				else
-					prev = q;
-			}
-			if(debug['V'])
-				print("%s unused (data)\n", s0->name);
-			p = prevt->link;
-		}
-		else{
-			prevt = p;
-			p = p->link;
-		}
-	}
-	for(i=0; i<NHASH; i++){
-		for(s = hash[i]; s != S; s = s->link){
-			if(s->used == 0)
-				s->type = SREMOVED;
-		}
-	}
-}
-
-static void
-fused(Adr *a, Prog *p, Prog *ct)
-{
-	Sym *s = a->sym;
-	Use *u;
-
-	if(s == S)
-		return;
-	if(a->type == D_OREG || a->type == D_OCONST || a->type == D_CONST){
-		if(a->name == D_EXTERN || a->name == D_STATIC){
-			u = malloc(sizeof(Use));
-			u->p = p;
-			u->ct = ct;
-			u->link = s->use;
-			s->use = u;
-		}
-	}
-	else if(a->type == D_BRANCH){
-		u = malloc(sizeof(Use));
-		u->p = p;
-		u->ct = ct;
-		u->link = s->use;
-		s->use = u;
-	}
-}
-
-static int
-ckfpuse(Prog *p, Prog *ct, Sym *fp, Sym *r)
-{
-	int reg;
-
-	USED(fp);
-	USED(ct);
-	if(p->from.sym == r && p->as == AMOVW && (p->from.type == D_CONST || p->from.type == D_OREG) && p->reg == NREG && p->to.type == D_REG){
-		reg = p->to.reg;
-		for(p = p->link; p != P && p->as != ATEXT; p = p->link){
-			if((p->as == ABL || p->as == ABX) && p->to.type == D_OREG && p->to.reg == reg)
-				return 1;
-			if(!debug['F'] && (isbranch(p) || p->as == ARET)){
-				// print("%s: branch %P in %s\n", fp->name, p, ct->from.sym->name);
-				return 0;
-			}
-			if((p->from.type == D_REG || p->from.type == D_OREG) && p->from.reg == reg){
-				if(!debug['F'] && p->to.type != D_REG){
-					// print("%s: store %P in %s\n", fp->name, p, ct->from.sym->name);
-					return 0;
-				}
-				reg = p->to.reg;
-			}
-		}
-	}
-	// print("%s: no MOVW O(R), R\n", fp->name);
-	return debug['F'];
-}
-
-static void
-setfpuse(Prog *p, Sym *fp, Sym *r)
-{
-	int reg;
-
-	if(p->from.sym == r && p->as == AMOVW && (p->from.type == D_CONST || p->from.type == D_OREG) && p->reg == NREG && p->to.type == D_REG){
-		reg = p->to.reg;
-		for(p = p->link; p != P && p->as != ATEXT; p = p->link){
-			if((p->as == ABL || p->as == ABX) && p->to.type == D_OREG && p->to.reg == reg){
-				fp->fnptr = 0;
-				p->as = ABL;	// safe to do so
-// print("simplified %s call\n", fp->name);
-				break;
-			}
-			if(!debug['F'] && (isbranch(p) || p->as == ARET))
-				diag("bad setfpuse call");
-			if((p->from.type == D_REG || p->from.type == D_OREG) && p->from.reg == reg){
-				if(!debug['F'] && p->to.type != D_REG)
-					diag("bad setfpuse call");
-				reg = p->to.reg;
-			}
-		}
-	}
-}
-
-static int
-cksymuse(Sym *s, int t)
-{
-	Prog *p;
-
-	for(p = datap; p != P; p = p->link){
-		if(p->from.sym == s && p->to.sym != nil && strcmp(p->to.sym->name, ".string") != 0 && p->to.sym->thumb != t){
-			// print("%s %s %d %d ", p->from.sym->name, p->to.sym->name, p->to.sym->thumb, t);
-			return 0;
-		}
-	}
-	return 1;
-}
-
-/* check the use of s at the given point */
-static int
-ckuse(Sym *s, Sym *s0, Use *u)
-{
-	Sym *s1;
-
-	s1 = u->p->from.sym;
-// print("ckuse %s %s %s\n", s->name, s0->name, s1 ? s1->name : "nil");
-	if(u->ct == nil){	/* in data area */
-		if(s0 == s && !cksymuse(s1, s0->thumb)){
-			// print("%s: cksymuse fails\n", s0->name);
-			return 0;
-		}
-		for(u = s1->use; u != U; u = u->link)
-			if(!ckuse(s1, s0, u))
-				return 0;
-	}
-	else{		/* in text area */
-		if(u->ct->from.sym->thumb != s0->thumb){
-			// print("%s(%d): foreign call %s(%d)\n", s0->name, s0->thumb, u->ct->from.sym->name, u->ct->from.sym->thumb);
-			return 0;
-		}
-		return ckfpuse(u->p, u->ct, s0, s);
-	}
-	return 1;
-}
-
-static void
-setuse(Sym *s, Sym *s0, Use *u)
-{
-	Sym *s1;
-
-	s1 = u->p->from.sym;
-	if(u->ct == nil){	/* in data area */
-		for(u = s1->use; u != U; u = u->link)
-			setuse(s1, s0, u);
-	}
-	else{		/* in text area */
-		setfpuse(u->p, s0, s);
-	}
-}
-
-/* detect BX O(R) which can be done as BL O(R) */
-void
-fnptrs()
-{
-	int i;
-	Sym *s;
-	Prog *p;
-	Use *u;
-
-	for(i=0; i<NHASH; i++){
-		for(s = hash[i]; s != S; s = s->link){
-			if(s->fnptr && (s->type == STEXT || s->type == SLEAF || s->type == SCONST)){
-				// print("%s : fnptr %d %d\n", s->name, s->thumb, s->foreign);
-			}
-		}
-	}
-	/* record use of syms */
-	for(p = firstp; p != P; p = p->link){
-		if(p->as == ATEXT)
-			curtext = p;
-		else{
-			fused(&p->from, p, curtext);
-			fused(&p->to, p, curtext);
-		}
-	}
-	for(p = datap; p != P; p = p->link)
-		fused(&p->to, p, nil);
-
-	/* now look for fn ptrs */
-	for(i=0; i<NHASH; i++){
-		for(s = hash[i]; s != S; s = s->link){
-			if(s->fnptr && (s->type == STEXT || s->type == SLEAF || s->type == SCONST)){
-				for(u = s->use; u != U; u = u->link){
-					if(!ckuse(s, s, u))
-						break;
-				}
-				if(u == U){		// can simplify
-					for(u = s->use; u != U; u = u->link)
-						setuse(s, s, u);
-				}
-			}
-		}
-	}
-
-	/*  now free Use structures */
-}
-
-void
-import(void)
-{
-	int i;
-	Sym *s;
-
-	for(i = 0; i < NHASH; i++)
-		for(s = hash[i]; s != S; s = s->link)
-			if(s->sig != 0 && s->type == SXREF && (nimports == 0 || s->subtype == SIMPORT)){
-				undefsym(s);
-				Bprint(&bso, "IMPORT: %s sig=%lux v=%ld\n", s->name, s->sig, s->value);
-			}
-}
-
-void
-ckoff(Sym *s, int32 v)
-{
-	if(v < 0 || v >= 1<<Roffset)
-		diag("relocation offset %ld for %s out of range", v, s->name);
-}
-
-Prog*
-newdata(Sym *s, int o, int w, int t)
-{
-	Prog *p;
-
-	p = prg();
-	p->link = datap;
-	datap = p;
-	p->as = ADATA;
-	p->reg = w;
-	p->from.type = D_OREG;
-	p->from.name = t;
-	p->from.sym = s;
-	p->from.offset = o;
-	p->to.type = D_CONST;
-	p->to.name = D_NONE;
-	s->data = p;
-	return p;
-}
-
-void
-export(void)
-{
-	int i, j, n, off, nb, sv, ne;
-	Sym *s, *et, *str, **esyms;
-	Prog *p;
-	char buf[NSNAME], *t;
-
-	n = 0;
-	for(i = 0; i < NHASH; i++)
-		for(s = hash[i]; s != S; s = s->link)
-			if(s->sig != 0 && s->type != SXREF && s->type != SUNDEF && (nexports == 0 || s->subtype == SEXPORT))
-				n++;
-	esyms = malloc(n*sizeof(Sym*));
-	ne = n;
-	n = 0;
-	for(i = 0; i < NHASH; i++)
-		for(s = hash[i]; s != S; s = s->link)
-			if(s->sig != 0 && s->type != SXREF && s->type != SUNDEF && (nexports == 0 || s->subtype == SEXPORT))
-				esyms[n++] = s;
-	for(i = 0; i < ne-1; i++)
-		for(j = i+1; j < ne; j++)
-			if(strcmp(esyms[i]->name, esyms[j]->name) > 0){
-				s = esyms[i];
-				esyms[i] = esyms[j];
-				esyms[j] = s;
-			}
-
-	nb = 0;
-	off = 0;
-	et = lookup(EXPTAB, 0);
-	if(et->type != 0 && et->type != SXREF)
-		diag("%s already defined", EXPTAB);
-	et->type = SDATA;
-	str = lookup(".string", 0);
-	if(str->type == 0)
-		str->type = SDATA;
-	sv = str->value;
-	for(i = 0; i < ne; i++){
-		s = esyms[i];
-		Bprint(&bso, "EXPORT: %s sig=%lux t=%d\n", s->name, s->sig, s->type);
-
-		/* signature */
-		p = newdata(et, off, sizeof(int32), D_EXTERN);
-		off += sizeof(int32);
-		p->to.offset = s->sig;
-
-		/* address */
-		p = newdata(et, off, sizeof(int32), D_EXTERN);
-		off += sizeof(int32);
-		p->to.name = D_EXTERN;
-		p->to.sym = s;
-
-		/* string */
-		t = s->name;
-		n = strlen(t)+1;
-		for(;;){
-			buf[nb++] = *t;
-			sv++;
-			if(nb >= NSNAME){
-				p = newdata(str, sv-NSNAME, NSNAME, D_STATIC);
-				p->to.type = D_SCONST;
-				p->to.sval = malloc(NSNAME);
-				memmove(p->to.sval, buf, NSNAME);
-				nb = 0;
-			}
-			if(*t++ == 0)
-				break;
-		}
-
-		/* name */
-		p = newdata(et, off, sizeof(int32), D_EXTERN);
-		off += sizeof(int32);
-		p->to.name = D_STATIC;
-		p->to.sym = str;
-		p->to.offset = sv-n;
-	}
-
-	if(nb > 0){
-		p = newdata(str, sv-nb, nb, D_STATIC);
-		p->to.type = D_SCONST;
-		p->to.sval = malloc(NSNAME);
-		memmove(p->to.sval, buf, nb);
-	}
-
-	for(i = 0; i < 3; i++){
-		newdata(et, off, sizeof(int32), D_EXTERN);
-		off += sizeof(int32);
-	}
-	et->value = off;
-	if(sv == 0)
-		sv = 1;
-	str->value = sv;
-	exports = ne;
-	free(esyms);
-}
diff --git a/src/cmd/5l/prof.c b/src/cmd/5l/prof.c
new file mode 100644
index 000000000..ad115a8ca
--- /dev/null
+++ b/src/cmd/5l/prof.c
@@ -0,0 +1,214 @@
+// Inferno utils/5l/obj.c
+// http://code.google.com/p/inferno-os/source/browse/utils/5l/obj.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.
+
+// Profiling.
+
+#include "l.h"
+#include "../ld/lib.h"
+
+void
+doprof1(void)
+{
+#if 0	// TODO(rsc)
+	Sym *s;
+	int32 n;
+	Prog *p, *q;
+
+	if(debug['v'])
+		Bprint(&bso, "%5.2f profile 1\n", cputime());
+	Bflush(&bso);
+	s = lookup("__mcount", 0);
+	n = 1;
+	for(p = firstp->link; p != P; p = p->link) {
+		setarch(p);
+		if(p->as == ATEXT) {
+			q = prg();
+			q->line = p->line;
+			q->link = datap;
+			datap = q;
+			q->as = ADATA;
+			q->from.type = D_OREG;
+			q->from.name = D_EXTERN;
+			q->from.offset = n*4;
+			q->from.sym = s;
+			q->reg = 4;
+			q->to = p->from;
+			q->to.type = D_CONST;
+
+			q = prg();
+			q->line = p->line;
+			q->pc = p->pc;
+			q->link = p->link;
+			p->link = q;
+			p = q;
+			p->as = AMOVW;
+			p->from.type = D_OREG;
+			p->from.name = D_EXTERN;
+			p->from.sym = s;
+			p->from.offset = n*4 + 4;
+			p->to.type = D_REG;
+			p->to.reg = thumb ? REGTMPT : REGTMP;
+
+			q = prg();
+			q->line = p->line;
+			q->pc = p->pc;
+			q->link = p->link;
+			p->link = q;
+			p = q;
+			p->as = AADD;
+			p->from.type = D_CONST;
+			p->from.offset = 1;
+			p->to.type = D_REG;
+			p->to.reg = thumb ? REGTMPT : REGTMP;
+
+			q = prg();
+			q->line = p->line;
+			q->pc = p->pc;
+			q->link = p->link;
+			p->link = q;
+			p = q;
+			p->as = AMOVW;
+			p->from.type = D_REG;
+			p->from.reg = thumb ? REGTMPT : REGTMP;
+			p->to.type = D_OREG;
+			p->to.name = D_EXTERN;
+			p->to.sym = s;
+			p->to.offset = n*4 + 4;
+
+			n += 2;
+			continue;
+		}
+	}
+	q = prg();
+	q->line = 0;
+	q->link = datap;
+	datap = q;
+
+	q->as = ADATA;
+	q->from.type = D_OREG;
+	q->from.name = D_EXTERN;
+	q->from.sym = s;
+	q->reg = 4;
+	q->to.type = D_CONST;
+	q->to.offset = n;
+
+	s->type = SBSS;
+	s->value = n*4;
+#endif
+}
+
+void
+doprof2(void)
+{
+	Sym *s2, *s4;
+	Prog *p, *q, *ps2, *ps4;
+
+	if(debug['v'])
+		Bprint(&bso, "%5.2f profile 2\n", cputime());
+	Bflush(&bso);
+	s2 = lookup("_profin", 0);
+	s4 = lookup("_profout", 0);
+	if(s2->type != STEXT || s4->type != STEXT) {
+		diag("_profin/_profout not defined");
+		return;
+	}
+	ps2 = P;
+	ps4 = P;
+	for(cursym = textp; cursym != nil; cursym = cursym->next) {
+		p = cursym->text;
+		setarch(p);
+		if(cursym == s2) {
+			ps2 = p;
+			p->reg = 1;
+		}
+		if(cursym == s4) {
+			ps4 = p;
+			p->reg = 1;
+		}
+	}
+	for(cursym = textp; cursym != nil; cursym = cursym->next)
+	for(p = cursym->text; p != P; p = p->link) {
+		setarch(p);
+		if(p->as == ATEXT) {
+			if(p->reg & NOPROF) {
+				for(;;) {
+					q = p->link;
+					if(q == P)
+						break;
+					if(q->as == ATEXT)
+						break;
+					p = q;
+				}
+				continue;
+			}
+
+			/*
+			 * BL	profin, R2
+			 */
+			q = prg();
+			q->line = p->line;
+			q->pc = p->pc;
+			q->link = p->link;
+			p->link = q;
+			p = q;
+			p->as = ABL;
+			p->to.type = D_BRANCH;
+			p->cond = ps2;
+			p->to.sym = s2;
+
+			continue;
+		}
+		if(p->as == ARET) {
+			/*
+			 * RET
+			 */
+			q = prg();
+			q->as = ARET;
+			q->from = p->from;
+			q->to = p->to;
+			q->link = p->link;
+			p->link = q;
+
+			/*
+			 * BL	profout
+			 */
+			p->as = ABL;
+			p->from = zprg.from;
+			p->to = zprg.to;
+			p->to.type = D_BRANCH;
+			p->cond = ps4;
+			p->to.sym = s4;
+
+			p = q;
+
+			continue;
+		}
+	}
+}
diff --git a/src/cmd/5l/softfloat.c b/src/cmd/5l/softfloat.c
index 82874ee1c..fd66b0969 100644
--- a/src/cmd/5l/softfloat.c
+++ b/src/cmd/5l/softfloat.c
@@ -5,67 +5,82 @@
 #define	EXTERN
 #include	"l.h"
 
+// Software floating point.
+
 void
-softfloat()
+softfloat(void)
 {
 	Prog *p, *next, *psfloat;
 	Sym *symsfloat;
 	int wasfloat;
-	
+
+	if(!debug['F'])
+		return;
+
 	symsfloat = lookup("_sfloat", 0);
 	psfloat = P;
 	if(symsfloat->type == STEXT)
-	for(p = firstp; p != P; p = p->link) {
-		if(p->as == ATEXT) {
-			if(p->from.sym == symsfloat) {
-				psfloat = p;
-				break;
-			}
-		}
-	}
+		psfloat = symsfloat->text;
+
+	for(cursym = textp; cursym != nil; cursym = cursym->next) {
+		wasfloat = 0;
+		for(p = cursym->text; p != P; p = p->link)
+			if(p->cond != P)
+				p->cond->mark |= LABEL;
+		for(p = cursym->text; p != P; p = p->link) {
+			switch(p->as) {
+			case AMOVW:
+				if(p->to.type == D_FREG || p->from.type == D_FREG)
+					goto soft;
+				goto notsoft;
+
+			case AMOVWD:
+			case AMOVWF:
+			case AMOVDW:
+			case AMOVFW:
+			case AMOVFD:
+			case AMOVDF:
+			case AMOVF:
+			case AMOVD:
+
+			case ACMPF:
+			case ACMPD:
+			case AADDF:
+			case AADDD:
+			case ASUBF:
+			case ASUBD:
+			case AMULF:
+			case AMULD:
+			case ADIVF:
+			case ADIVD:
+				goto soft;
 
-	wasfloat = 0;
-	p = firstp;
-	for(p = firstp; p != P; p = p->link) {
-		switch(p->as) {
-		case AMOVWD:
-		case AMOVWF:
-		case AMOVDW:
-		case AMOVFW:
-		case AMOVFD:
-		case AMOVDF:
-		case AMOVF:
-		case AMOVD:
-		case ACMPF:
-		case ACMPD:
-		case AADDF:
-		case AADDD:
-		case ASUBF:
-		case ASUBD:
-		case AMULF:
-		case AMULD:
-		case ADIVF:
-		case ADIVD:
-			if (psfloat == P)
-				diag("floats used with _sfloat not defined");
-			if (!wasfloat) {
-				next = prg();
-				*next = *p;
+			default:
+				goto notsoft;
 
-				// BL		_sfloat(SB)
-				*p = zprg;
-				p->link = next;
-				p->as = ABL;
- 				p->to.type = D_BRANCH;
-				p->to.sym = symsfloat;
-				p->cond = psfloat;
+			soft:
+				if (psfloat == P)
+					diag("floats used with _sfloat not defined");
+				if (!wasfloat || (p->mark&LABEL)) {
+					next = prg();
+					*next = *p;
+	
+					// BL _sfloat(SB)
+					*p = zprg;
+					p->link = next;
+					p->as = ABL;
+	 				p->to.type = D_BRANCH;
+					p->to.sym = symsfloat;
+					p->cond = psfloat;
+	
+					p = next;
+					wasfloat = 1;
+				}
+				break;
 
-				p = next;
-				wasfloat = 1;
+			notsoft:
+				wasfloat = 0;
 			}
-			break;
-		default:
-			wasfloat = 0;
 		}
 	}
 }
diff --git a/src/cmd/5l/span.c b/src/cmd/5l/span.c
index a97af07f9..be0f5e8b3 100644
--- a/src/cmd/5l/span.c
+++ b/src/cmd/5l/span.c
@@ -28,6 +28,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+// Instruction layout.
+
 #include	"l.h"
 #include	"../ld/lib.h"
 
@@ -52,9 +54,9 @@ ispad(Prog *p)
 {
 	if(p->as != AMOVW)
 		return 0;
-	if(p->from.type != D_REG || p->from.reg != REGSB)
+	if(p->from.type != D_REG || p->from.reg != REGTMP)
 		return 0;
-	if(p->to.type != D_REG || p->to.reg != REGSB)
+	if(p->to.type != D_REG || p->to.reg != REGTMP)
 		return 0;
 	return 1;
 }
@@ -100,7 +102,7 @@ fnpinc(Sym *s)
 		if(!debug['f'])
 			diag("fnptr == 0 in fnpinc");
 		if(s->foreign)
-			diag("bad usage in fnpinc %s %d %d %d", s->name, s->used, s->foreign, s->thumb);
+			diag("bad usage in fnpinc %s %d %d", s->name, s->foreign, s->thumb);
 		return 0;
 	}
 	/* 0, 1, 2, 3 squared */
@@ -119,9 +121,9 @@ pad(Prog *p, int pc)
 	q->as = AMOVW;
 	q->line = p->line;
 	q->from.type = D_REG;
-	q->from.reg = REGSB;
+	q->from.reg = REGTMP;
 	q->to.type = D_REG;
-	q->to.reg = REGSB;
+	q->to.reg = REGTMP;
 	q->pc = pc;
 	q->link = p->link;
 	return q;
@@ -132,7 +134,7 @@ scan(Prog *op, Prog *p, int c)
 {
 	Prog *q;
 
-	for(q = op->link; q != p; q = q->link){
+	for(q = op->link; q != p && q != P; q = q->link){
 		q->pc = c;
 		c += oplook(q)->size;
 		nocache(q);
@@ -163,11 +165,12 @@ void
 span(void)
 {
 	Prog *p, *op;
-	Sym *setext, *s;
 	Optab *o;
-	int m, bflag, i;
-	int32 c, otxt, v;
+	int m, bflag, i, v;
+	int32 c, otxt, out[6];
 	int lastthumb = -1;
+	Section *sect;
+	uchar *bp;
 
 	if(debug['v'])
 		Bprint(&bso, "%5.2f span\n", cputime());
@@ -176,61 +179,65 @@ span(void)
 	bflag = 0;
 	c = INITTEXT;
 	op = nil;
+	p = nil;
 	otxt = c;
-	for(p = firstp; p != P; op = p, p = p->link) {
+	for(cursym = textp; cursym != nil; cursym = cursym->next) {
+		p = cursym->text;
 		setarch(p);
 		p->pc = c;
-		o = oplook(p);
-		m = o->size;
-		// must check literal pool here in case p generates many instructions
-		if(blitrl){
-			if(thumb && isbranch(p))
-				pool.extra += brextra(p);
-			if(checkpool(op, p->as == ACASE ? casesz(p) : m))
-				c = p->pc = scan(op, p, c);
-		}
-		if(m == 0) {
-			if(p->as == ATEXT) {
-				if(blitrl && lastthumb != -1 && lastthumb != thumb){	// flush literal pool
-					if(flushpool(op, 0, 1))
-						c = p->pc = scan(op, p, c);
-				}
-				lastthumb = thumb;
-				curtext = p;
-				autosize = p->to.offset + 4;
-				if(p->from.sym != S)
-					p->from.sym->value = c;
-				/* need passes to resolve branches */
-				if(c-otxt >= 1L<<17)
-					bflag = 1;
-				otxt = c;
-				if(thumb && blitrl)
+		cursym->value = c;
+
+		lastthumb = thumb;
+		autosize = p->to.offset + 4;
+		if(p->from.sym != S)
+			p->from.sym->value = c;
+		/* need passes to resolve branches */
+		if(c-otxt >= 1L<<17)
+			bflag = 1;
+		otxt = c;
+		if(thumb && blitrl)
+			pool.extra += brextra(p);
+
+		for(op = p, p = p->link; p != P; op = p, p = p->link) {
+			curp = p;
+			setarch(p);
+			p->pc = c;
+			o = oplook(p);
+			m = o->size;
+			// must check literal pool here in case p generates many instructions
+			if(blitrl){
+				if(thumb && isbranch(p))
 					pool.extra += brextra(p);
+				if(checkpool(op, p->as == ACASE ? casesz(p) : m))
+					c = p->pc = scan(op, p, c);
+			}
+			if(m == 0) {
+				diag("zero-width instruction\n%P", p);
 				continue;
 			}
-			diag("zero-width instruction\n%P", p);
-			continue;
-		}
-		switch(o->flag & (LFROM|LTO|LPOOL)) {
-		case LFROM:
-			addpool(p, &p->from);
-			break;
-		case LTO:
-			addpool(p, &p->to);
-			break;
-		case LPOOL:
-			if ((p->scond&C_SCOND) == 14)
+			switch(o->flag & (LFROM|LTO|LPOOL)) {
+			case LFROM:
+				addpool(p, &p->from);
+				break;
+			case LTO:
+				addpool(p, &p->to);
+				break;
+			case LPOOL:
+				if ((p->scond&C_SCOND) == 14)
+					flushpool(p, 0, 0);
+				break;
+			}
+			if(p->as==AMOVW && p->to.type==D_REG && p->to.reg==REGPC && (p->scond&C_SCOND) == 14)
 				flushpool(p, 0, 0);
-			break;
+			c += m;
 		}
-		if(p->as==AMOVW && p->to.type==D_REG && p->to.reg==REGPC && (p->scond&C_SCOND) == 14)
-			flushpool(p, 0, 0);
-		c += m;
-		if(blitrl && p->link == P){
-			if(thumb && isbranch(p))
-				pool.extra += brextra(p);
-			checkpool(p, 0);
+		if(blitrl){
+			if(thumb && isbranch(op))
+				pool.extra += brextra(op);
+			if(checkpool(op, 0))
+				c = scan(op, P, c);
 		}
+		cursym->size = c - cursym->value;
 	}
 
 	/*
@@ -244,48 +251,52 @@ span(void)
 			Bprint(&bso, "%5.2f span1\n", cputime());
 		bflag = 0;
 		c = INITTEXT;
-		for(p = firstp; p != P; p = p->link) {
-			setarch(p);
-			p->pc = c;
-			if(thumb && isbranch(p))
-				nocache(p);
-			o = oplook(p);
-/* very larg branches
-			if(o->type == 6 && p->cond) {
-				otxt = p->cond->pc - c;
-				if(otxt < 0)
-					otxt = -otxt;
-				if(otxt >= (1L<<17) - 10) {
-					q = prg();
-					q->link = p->link;
-					p->link = q;
-					q->as = AB;
-					q->to.type = D_BRANCH;
-					q->cond = p->cond;
-					p->cond = q;
-					q = prg();
-					q->link = p->link;
-					p->link = q;
-					q->as = AB;
-					q->to.type = D_BRANCH;
-					q->cond = q->link->link;
-					bflag = 1;
+		for(cursym = textp; cursym != nil; cursym = cursym->next) {
+			cursym->value = c;
+			for(p = cursym->text; p != P; p = p->link) {
+				curp = p;
+				setarch(p);
+				p->pc = c;
+				if(thumb && isbranch(p))
+					nocache(p);
+				o = oplook(p);
+/* very large branches
+				if(o->type == 6 && p->cond) {
+					otxt = p->cond->pc - c;
+					if(otxt < 0)
+						otxt = -otxt;
+					if(otxt >= (1L<<17) - 10) {
+						q = prg();
+						q->link = p->link;
+						p->link = q;
+						q->as = AB;
+						q->to.type = D_BRANCH;
+						q->cond = p->cond;
+						p->cond = q;
+						q = prg();
+						q->link = p->link;
+						p->link = q;
+						q->as = AB;
+						q->to.type = D_BRANCH;
+						q->cond = q->link->link;
+						bflag = 1;
+					}
 				}
-			}
  */
-			m = o->size;
-			if(m == 0) {
-				if(p->as == ATEXT) {
-					curtext = p;
-					autosize = p->to.offset + 4;
-					if(p->from.sym != S)
-						p->from.sym->value = c;
+				m = o->size;
+				if(m == 0) {
+					if(p->as == ATEXT) {
+						autosize = p->to.offset + 4;
+						if(p->from.sym != S)
+							p->from.sym->value = c;
+						continue;
+					}
+					diag("zero-width instruction\n%P", p);
 					continue;
 				}
-				diag("zero-width instruction\n%P", p);
-				continue;
+				c += m;
 			}
-			c += m;
+			cursym->size = c - cursym->value;
 		}
 	}
 
@@ -304,107 +315,94 @@ span(void)
 		c = INITTEXT;
 		oop = op = nil;
 		again = 0;
-		for(p = firstp; p != P; oop = op, op = p, p = p->link){
-			setarch(p);
-			if(p->pc != c)
-				again = 1;
-			p->pc = c;
-			if(thumb && isbranch(p))
-				nocache(p);
-			o = oplook(p);
-			m = o->size;
-			if(passes == 1 && thumb && isbranch(p)){	// start conservative so unneeded alignment is not added
-				if(p->as == ABL)
-					m = 4;
-				else
-					m = 2;
-				p->align = 0;
-			}
-			if(p->align){
-				if((p->align == 4 && (c&3)) || (p->align == 2 && !(c&3))){
-					if(ispad(op)){
-						oop->link = p;
-						op = oop;
-						c -= 2;
-						p->pc = c;
-					}
-					else{
-						op->link = pad(op, c);
-						op = op->link;
-						c += 2;
-						p->pc = c;
-					}
+		for(cursym = textp; cursym != nil; cursym = cursym->next) {
+			cursym->value = c;
+			for(p = cursym->text; p != P; oop = op, op = p, p = p->link) {
+				curp = p;
+				setarch(p);
+				if(p->pc != c)
 					again = 1;
+				p->pc = c;
+				if(thumb && isbranch(p))
+					nocache(p);
+				o = oplook(p);
+				m = o->size;
+				if(passes == 1 && thumb && isbranch(p)){	// start conservative so unneeded alignment is not added
+					if(p->as == ABL)
+						m = 4;
+					else
+						m = 2;
+					p->align = 0;
 				}
-			}
-			if(m == 0) {
-				if(p->as == ATEXT) {
-					curtext = p;
-					autosize = p->to.offset + 4;
-					if(p->from.sym != S)
-						p->from.sym->value = c;
-					continue;
+				if(p->align){
+					if((p->align == 4 && (c&3)) || (p->align == 2 && !(c&3))){
+						if(ispad(op)){
+							oop->link = p;
+							op = oop;
+							c -= 2;
+							p->pc = c;
+						}
+						else{
+							op->link = pad(op, c);
+							op = op->link;
+							c += 2;
+							p->pc = c;
+						}
+						again = 1;
+					}
+				}
+				if(m == 0) {
+					if(p->as == ATEXT) {
+						autosize = p->to.offset + 4;
+						if(p->from.sym != S)
+							p->from.sym->value = c;
+						continue;
+					}
 				}
+				c += m;
 			}
-			c += m;
+			cursym->size = c - cursym->value;
 		}
 		if(c != lastc || again){
 			lastc = c;
 			goto loop;
 		}
 	}
-
-	if(0 && seenthumb){		// rm redundant padding - obsolete
-		int d;
-
-		op = nil;
-		d = 0;
-		for(p = firstp; p != P; op = p, p = p->link){
-			p->pc -= d;
-			if(p->as == ATEXT){
-				if(p->from.sym != S)
-					p->from.sym->value -= d;
-// if(p->from.sym != S) print("%s %ux %d %d %d\n", p->from.sym->name ? p->from.sym->name : "?", p->from.sym->value, p->from.sym->thumb, p->from.sym->foreign, p->from.sym->fnptr);
-			}
-			if(ispad(p) && p->link != P && ispad(p->link)){
-				op->link = p->link->link;
-				d += 4;
-				p = op;
+	c = rnd(c, 8);
+	
+	/*
+	 * lay out the code.  all the pc-relative code references,
+	 * even cross-function, are resolved now;
+	 * only data references need to be relocated.
+	 * with more work we could leave cross-function
+	 * code references to be relocated too, and then
+	 * perhaps we'd be able to parallelize the span loop above.
+	 */
+	for(cursym = textp; cursym != nil; cursym = cursym->next) {
+		p = cursym->text;
+		setarch(p);
+		autosize = p->to.offset + 4;
+		symgrow(cursym, cursym->size);
+	
+		bp = cursym->p;
+		for(p = p->link; p != P; p = p->link) {
+			curp = p;
+			pc = p->pc;
+			curp = p;
+			o = oplook(p);
+			asmout(p, o, out);
+			for(i=0; i<o->size/4; i++) {
+				v = out[i];
+				*bp++ = v;
+				*bp++ = v>>8;
+				*bp++ = v>>16;
+				*bp++ = v>>24;
 			}
 		}
-		// print("%d bytes removed (padding)\n", d);
-		c -= d;
 	}
-
-	if(debug['t']) {
-		/*
-		 * add strings to text segment
-		 */
-		c = rnd(c, 8);
-		for(i=0; i<NHASH; i++)
-		for(s = hash[i]; s != S; s = s->link) {
-			if(s->type != SSTRING)
-				continue;
-			v = s->value;
-			while(v & 3)
-				v++;
-			s->value = c;
-			c += v;
-		}
-	}
-
-	c = rnd(c, 8);
-
-	setext = lookup("etext", 0);
-	if(setext != S) {
-		setext->value = c;
-		textsize = c - INITTEXT;
-	}
-	if(INITRND)
-		INITDAT = rnd(c, INITRND);
-	if(debug['v'])
-		Bprint(&bso, "tsize = %lux\n", textsize);
-	Bflush(&bso);
+	sect = addsection(&segtext, ".text", 05);
+	sect->vaddr = INITTEXT;
+	sect->len = c - INITTEXT;
 }
 
 /*
@@ -437,7 +435,7 @@ flushpool(Prog *p, int skip, int force)
 
 	if(blitrl) {
 		if(skip){
-			if(0 && skip==1)print("note: flush literal pool at %lux: len=%lud ref=%lux\n", p->pc+4, pool.size, pool.start);
+			if(0 && skip==1)print("note: flush literal pool at %ux: len=%ud ref=%ux\n", p->pc+4, pool.size, pool.start);
 			q = prg();
 			q->as = AB;
 			q->to.type = D_BRANCH;
@@ -523,10 +521,10 @@ xdefine(char *p, int t, int32 v)
 	Sym *s;
 
 	s = lookup(p, 0);
-	if(s->type == 0 || s->type == SXREF) {
-		s->type = t;
-		s->value = v;
-	}
+	s->type = t;
+	s->value = v;
+	s->reachable = 1;
+	s->special = 1;
 }
 
 int32
@@ -583,6 +581,38 @@ immhalf(int32 v)
 	return 0;
 }
 
+int32
+symaddr(Sym *s)
+{
+	int32 v;
+
+	v = s->value;
+	switch(s->type) {
+	default:
+		diag("unexpected type %d in symaddr(%s)", s->type, s->name);
+		return 0;
+	
+	case STEXT:
+/* TODO(rsc): what is this for?
+#ifdef CALLEEBX
+		v += fnpinc(s);
+#else
+		if(s->thumb)
+			v++;	// T bit
+#endif
+*/
+		break;
+	
+	case SELFDATA:
+	case SRODATA:
+	case SDATA:
+	case SBSS:
+	case SCONST:
+		break;
+	}
+	return v;
+}
+
 int
 aclass(Adr *a)
 {
@@ -619,36 +649,9 @@ aclass(Adr *a)
 			}
 			s = a->sym;
 			t = s->type;
-			if(t == 0 || t == SXREF) {
-				diag("undefined external: %s in %s",
-					s->name, TNAME);
-				s->type = SDATA;
-			}
-			if(dlm) {
-				switch(t) {
-				default:
-					instoffset = s->value + a->offset + INITDAT;
-					break;
-				case SUNDEF:
-				case STEXT:
-				case SCONST:
-				case SLEAF:
-				case SSTRING:
-					instoffset = s->value + a->offset;
-					break;
-				}
-				return C_ADDR;
-			}
-			instoffset = s->value + a->offset - BIG;
-			t = immaddr(instoffset);
-			if(t) {
-				if(immhalf(instoffset))
-					return immfloat(t) ? C_HFEXT : C_HEXT;
-				if(immfloat(t))
-					return C_FEXT;
-				return C_SEXT;
-			}
-			return C_LEXT;
+			instoffset = 0;	// s.b. unused but just in case
+			return C_ADDR;
+
 		case D_AUTO:
 			instoffset = autosize + a->offset;
 			t = immaddr(instoffset);
@@ -703,32 +706,17 @@ aclass(Adr *a)
 		case D_STATIC:
 			s = a->sym;
 			t = s->type;
-			if(t == 0 || t == SXREF) {
-				diag("undefined external: %s in %s",
-					s->name, TNAME);
-				s->type = SDATA;
-			}
-			if(s->type == SFIXED) {
-				instoffset = s->value + a->offset;
-				return C_LCON;
-			}
-			instoffset = s->value + a->offset + INITDAT;
-			if(s->type == STEXT || s->type == SLEAF || s->type == SUNDEF) {
-				instoffset = s->value + a->offset;
-#ifdef CALLEEBX
-				instoffset += fnpinc(s);
-#else
-				if(s->thumb)
-					instoffset++;	// T bit
-#endif
-				return C_LCON;
-			}
-			return C_LCON;
+			instoffset = 0;	// s.b. unused but just in case
+			return C_ADDR;
 		}
 		return C_GOK;
 
 	case D_FCONST:
-		return C_FCON;
+		if(chipzero(&a->ieee) >= 0)
+			return C_ZFCON;
+		if(chipfloat(&a->ieee) >= 0)
+			return C_SFCON;
+		return C_LFCON;
 
 	case D_CONST:
 	case D_CONST2:
@@ -753,37 +741,7 @@ aclass(Adr *a)
 			if(s == S)
 				break;
 			t = s->type;
-			switch(t) {
-			case 0:
-			case SXREF:
-				diag("undefined external: %s in %s",
-					s->name, TNAME);
-				s->type = SDATA;
-				break;
-			case SFIXED:
-				instoffset = s->value + a->offset;
-				return C_LCON;
-			case SUNDEF:
-			case STEXT:
-			case SSTRING:
-			case SCONST:
-			case SLEAF:
-				instoffset = s->value + a->offset;
-#ifdef CALLEEBX
-				instoffset += fnpinc(s);
-#else
-				if(s->thumb)
-					instoffset++;	// T bit
-#endif
-				return C_LCON;
-			}
-			if(!dlm) {
-				instoffset = s->value + a->offset - BIG;
-				t = immrot(instoffset);
-				if(t && instoffset != 0)
-					return C_RECON;
-			}
-			instoffset = s->value + a->offset + INITDAT;
+			instoffset = 0;	// s.b. unused but just in case
 			return C_LCON;
 
 		case D_AUTO:
@@ -895,21 +853,11 @@ cmp(int a, int b)
 		if(b == C_RACON)
 			return 1;
 		break;
-	case C_LECON:
-		if(b == C_RECON)
+	case C_LFCON:
+		if(b == C_ZFCON || b == C_SFCON)
 			return 1;
 		break;
 
-	case C_HFEXT:
-		return b == C_HEXT || b == C_FEXT;
-	case C_FEXT:
-	case C_HEXT:
-		return b == C_HFEXT;
-	case C_SEXT:
-		return cmp(C_HFEXT, b);
-	case C_LEXT:
-		return cmp(C_SEXT, b);
-
 	case C_HFAUTO:
 		return b == C_HAUTO || b == C_FAUTO;
 	case C_FAUTO:
@@ -1091,17 +1039,20 @@ buildop(void)
 			break;
 
 		case AMOVFW:
-			oprange[AMOVWF] = oprange[r];
-			oprange[AMOVWD] = oprange[r];
 			oprange[AMOVDW] = oprange[r];
 			break;
 
+		case AMOVWF:
+			oprange[AMOVWD] = oprange[r];
+			break;
+
 		case AMULL:
 			oprange[AMULA] = oprange[r];
 			oprange[AMULAL] = oprange[r];
 			oprange[AMULLU] = oprange[r];
 			oprange[AMULALU] = oprange[r];
 			break;
+
 		case ALDREX:
 		case ASTREX:
 			break;
@@ -1146,159 +1097,3 @@ buildrep(int x, int as)
 	oprange[as].start = 0;
 }
 */
-
-enum{
-	ABSD = 0,
-	ABSU = 1,
-	RELD = 2,
-	RELU = 3,
-};
-
-int modemap[4] = { 0, 1, -1, 2, };
-
-typedef struct Reloc Reloc;
-
-struct Reloc
-{
-	int n;
-	int t;
-	uchar *m;
-	uint32 *a;
-};
-
-Reloc rels;
-
-static void
-grow(Reloc *r)
-{
-	int t;
-	uchar *m, *nm;
-	uint32 *a, *na;
-
-	t = r->t;
-	r->t += 64;
-	m = r->m;
-	a = r->a;
-	r->m = nm = malloc(r->t*sizeof(uchar));
-	r->a = na = malloc(r->t*sizeof(uint32));
-	memmove(nm, m, t*sizeof(uchar));
-	memmove(na, a, t*sizeof(uint32));
-	free(m);
-	free(a);
-}
-
-void
-dynreloc(Sym *s, int32 v, int abs)
-{
-	int i, k, n;
-	uchar *m;
-	uint32 *a;
-	Reloc *r;
-
-	if(v&3)
-		diag("bad relocation address");
-	v >>= 2;
-	if(s != S && s->type == SUNDEF)
-		k = abs ? ABSU : RELU;
-	else
-		k = abs ? ABSD : RELD;
-	/* Bprint(&bso, "R %s a=%ld(%lx) %d\n", s->name, a, a, k); */
-	k = modemap[k];
-	r = &rels;
-	n = r->n;
-	if(n >= r->t)
-		grow(r);
-	m = r->m;
-	a = r->a;
-	for(i = n; i > 0; i--){
-		if(v < a[i-1]){	/* happens occasionally for data */
-			m[i] = m[i-1];
-			a[i] = a[i-1];
-		}
-		else
-			break;
-	}
-	m[i] = k;
-	a[i] = v;
-	r->n++;
-}
-
-static int
-sput(char *s)
-{
-	char *p;
-
-	p = s;
-	while(*s)
-		cput(*s++);
-	cput(0);
-	return  s-p+1;
-}
-
-void
-asmdyn()
-{
-	int i, n, t, c;
-	Sym *s;
-	uint32 la, ra, *a;
-	vlong off;
-	uchar *m;
-	Reloc *r;
-
-	cflush();
-	off = seek(cout, 0, 1);
-	lput(0);
-	t = 0;
-	lput(imports);
-	t += 4;
-	for(i = 0; i < NHASH; i++)
-		for(s = hash[i]; s != S; s = s->link)
-			if(s->type == SUNDEF){
-				lput(s->sig);
-				t += 4;
-				t += sput(s->name);
-			}
-
-	la = 0;
-	r = &rels;
-	n = r->n;
-	m = r->m;
-	a = r->a;
-	lput(n);
-	t += 4;
-	for(i = 0; i < n; i++){
-		ra = *a-la;
-		if(*a < la)
-			diag("bad relocation order");
-		if(ra < 256)
-			c = 0;
-		else if(ra < 65536)
-			c = 1;
-		else
-			c = 2;
-		cput((c<<6)|*m++);
-		t++;
-		if(c == 0){
-			cput(ra);
-			t++;
-		}
-		else if(c == 1){
-			wput(ra);
-			t += 2;
-		}
-		else{
-			lput(ra);
-			t += 4;
-		}
-		la = *a++;
-	}
-
-	cflush();
-	seek(cout, off, 0);
-	lput(t);
-
-	if(debug['v']){
-		Bprint(&bso, "import table entries = %d\n", imports);
-		Bprint(&bso, "export table entries = %d\n", exports);
-	}
-}
diff --git a/src/cmd/5l/thumb.c b/src/cmd/5l/thumb.c
index 97292f640..b2ba630c3 100644
--- a/src/cmd/5l/thumb.c
+++ b/src/cmd/5l/thumb.c
@@ -203,9 +203,8 @@ thumbaclass(Adr *a, Prog *p)
 					a->sym->name, TNAME);
 				a->sym->type = SDATA;
 			}
-			instoffset = a->sym->value + a->offset + INITDAT;
-			return C_LEXT;	/* INITDAT unknown at this stage */
-			// return immacon(instoffset, p, C_SEXT, C_LEXT);
+			instoffset = a->sym->value + a->offset;
+			return C_ADDR;	/* INITDAT unknown at this stage */
 		case D_AUTO:
 			instoffset = autosize + a->offset;
 			return immauto(instoffset, p);
@@ -235,8 +234,8 @@ thumbaclass(Adr *a, Prog *p)
 					s->name, TNAME);
 				s->type = SDATA;
 			}
-			instoffset = s->value + a->offset + INITDAT;
-			if(s->type == STEXT || s->type == SLEAF){
+			instoffset = s->value + a->offset;
+			if(s->type == STEXT){
 				instoffset = s->value + a->offset;
 #ifdef CALLEEBX
 				instoffset += fnpinc(s);
@@ -252,7 +251,7 @@ thumbaclass(Adr *a, Prog *p)
 		return C_GOK;
 	case D_FCONST:
 		diag("D_FCONST in thumaclass");
-		return C_FCON;
+		return C_LFCON;
 	case D_CONST:
 		switch(a->name) {
 		case D_NONE:
@@ -275,7 +274,6 @@ thumbaclass(Adr *a, Prog *p)
 				break;
 			case SCONST:
 			case STEXT:
-			case SLEAF:
 				instoffset = s->value + a->offset;
 #ifdef CALLEEBX
 				instoffset += fnpinc(s);
@@ -285,7 +283,7 @@ thumbaclass(Adr *a, Prog *p)
 #endif
 				return C_LCON;
 			}
-			instoffset = s->value + a->offset + INITDAT;
+			instoffset = s->value + a->offset;
 			return C_LCON;	/* INITDAT unknown at this stage */
 			// return immcon(instoffset, p);
 		case D_AUTO:
@@ -358,8 +356,8 @@ thumbaclass(Adr *a, Prog *p)
 // as a1 a2 a3 type size param lit vers
 Optab thumboptab[] =
 {
-	{ ATEXT,		C_LEXT,		C_NONE,		C_LCON,		0,	0,	0 },
-	{ ATEXT,		C_LEXT,		C_REG,		C_LCON,		0,	0,	0 },
+	{ ATEXT,		C_ADDR,		C_NONE,		C_LCON,		0,	0,	0 },
+	{ ATEXT,		C_ADDR,		C_REG,		C_LCON,		0,	0,	0 },
 	{ AMVN,		C_REG,		C_NONE,		C_REG,		1,	2,	0 },
 	{ ASRL,		C_REG,		C_NONE,		C_REG,		1,	2,	0 },
 	{ ACMP,		C_REG,		C_REG,		C_NONE,		1,	2,	0 },
@@ -412,37 +410,27 @@ Optab thumboptab[] =
 	{ ASWI,		C_NONE,		C_NONE,		C_LCON,		16,	2,	0 },
 	{ AWORD,		C_NONE,		C_NONE,		C_LCON,		17,	4,	0 },
 	{ AWORD,		C_NONE,		C_NONE,		C_GCON,		17,	4,	0 },
-	{ AWORD,		C_NONE,		C_NONE,		C_LEXT,		17,	4, 	0 },
+	{ AWORD,		C_NONE,		C_NONE,		C_ADDR,		17,	4, 	0 },
 	{ ADWORD,	C_LCON,		C_NONE,		C_LCON,		50,	8,	0 },
 	{ AMOVW,		C_SAUTO,		C_NONE,		C_REG,		18,	2,	REGSP },
 	{ AMOVW,		C_LAUTO,		C_NONE,		C_REG,		33,	6,	0,	LFROM  },
 	// { AMOVW,		C_OFFPC,		C_NONE,		C_REG,		18,	2,	REGPC,	LFROM  },
-	{ AMOVW,		C_SEXT,		C_NONE,		C_REG,		30,	4,	0 },
 	{ AMOVW,		C_SOREG,		C_NONE,		C_REG,		19,	2,	0 },
-	{ AMOVHU,	C_SEXT,		C_NONE,		C_REG,		30,	4,	0 },
 	{ AMOVHU,	C_SOREG,		C_NONE,		C_REG,		19,	2,	0 },
-	{ AMOVBU,	C_SEXT,		C_NONE,		C_REG,		30,	4,	0 },
 	{ AMOVBU,	C_SOREG,		C_NONE,		C_REG,		19,	2,	0 },
 	{ AMOVW,		C_REG,		C_NONE,		C_SAUTO,		20,	2,	0 },
 	{ AMOVW,		C_REG,		C_NONE,		C_LAUTO,		34,	6,	0,	LTO },
-	{ AMOVW,		C_REG,		C_NONE,		C_SEXT,		31,	4,	0 },
 	{ AMOVW,		C_REG,		C_NONE,		C_SOREG,		21,	2,	0 },
-	{ AMOVH,		C_REG,		C_NONE,		C_SEXT,		31,	4,	0 },
 	{ AMOVH,		C_REG,		C_NONE,		C_SOREG,		21,	2,	0 },
-	{ AMOVB,		C_REG,		C_NONE,		C_SEXT,		31,	4,	0 },
 	{ AMOVB,		C_REG,		C_NONE,		C_SOREG,		21,	2,	0 },
-	{ AMOVHU,	C_REG,		C_NONE,		C_SEXT,		31,	4,	0 },
 	{ AMOVHU,	C_REG,		C_NONE,		C_SOREG,		21,	2,	0 },
-	{ AMOVBU,	C_REG,		C_NONE,		C_SEXT,		31,	4,	0 },
 	{ AMOVBU,	C_REG,		C_NONE,		C_SOREG,		21,	2,	0 },
 	{ AMOVW,		C_REG,		C_NONE,		C_REG,		22,	2,	0 },
 	{ AMOVB,		C_REG,		C_NONE,		C_REG,		23,	4,	0 },
 	{ AMOVH,		C_REG,		C_NONE,		C_REG,		23,	4,	0 },
 	{ AMOVBU,	C_REG,		C_NONE,		C_REG,		23,	4,	0 },
 	{ AMOVHU,	C_REG,		C_NONE,		C_REG,		23,	4,	0 },
-	{ AMOVH,		C_SEXT,		C_NONE,		C_REG,		32,	6,	0 },
 	{ AMOVH,		C_SOREG,		C_NONE,		C_REG,		24,	4,	0 },
-	{ AMOVB,		C_SEXT,		C_NONE,		C_REG,		32,	6,	0 },
 	{ AMOVB,		C_SOREG,		C_NONE,		C_REG,		24,	4,	0 },
 	{ AMOVW,		C_SACON,	C_NONE,		C_REG,		25,	2,	0 },
 	{ AMOVW,		C_LACON,	C_NONE,		C_REG,		35,	4,	0 },
@@ -469,16 +457,16 @@ Optab thumboptab[] =
 	{ AMOVB,		C_REG,		C_NONE,		C_GOREG,		29,	4,	0,	LTO },
 	{ AMOVHU,	C_REG,		C_NONE,		C_GOREG,		29,	4,	0,	LTO },
 	{ AMOVBU,	C_REG,		C_NONE,		C_GOREG,		29,	4,	0,	LTO },
-	{ AMOVW,		C_LEXT,		C_NONE,		C_REG,		30,	4,	0,	LFROM },
-	{ AMOVH,		C_LEXT,		C_NONE,		C_REG,		32,	6,	0,	LFROM },
-	{ AMOVB,		C_LEXT,		C_NONE,		C_REG,		32,	6,	0,	LFROM },
-	{ AMOVHU,	C_LEXT,		C_NONE,		C_REG,		30,	4,	0,	LFROM },
-	{ AMOVBU,	C_LEXT,		C_NONE,		C_REG,		30,	4,	0,	LFROM },
-	{ AMOVW,		C_REG,		C_NONE,		C_LEXT,		31,	4,	0,	LTO },
-	{ AMOVH,		C_REG,		C_NONE,		C_LEXT,		31,	4,	0,	LTO },
-	{ AMOVB,		C_REG,		C_NONE,		C_LEXT,		31,	4,	0,	LTO },
-	{ AMOVHU,	C_REG,		C_NONE,		C_LEXT,		31,	4,	0,	LTO },
-	{ AMOVBU,	C_REG,		C_NONE,		C_LEXT,		31,	4,	0,	LTO },
+	{ AMOVW,		C_ADDR,		C_NONE,		C_REG,		30,	4,	0,	LFROM },
+	{ AMOVH,		C_ADDR,		C_NONE,		C_REG,		32,	6,	0,	LFROM },
+	{ AMOVB,		C_ADDR,		C_NONE,		C_REG,		32,	6,	0,	LFROM },
+	{ AMOVHU,	C_ADDR,		C_NONE,		C_REG,		30,	4,	0,	LFROM },
+	{ AMOVBU,	C_ADDR,		C_NONE,		C_REG,		30,	4,	0,	LFROM },
+	{ AMOVW,		C_REG,		C_NONE,		C_ADDR,		31,	4,	0,	LTO },
+	{ AMOVH,		C_REG,		C_NONE,		C_ADDR,		31,	4,	0,	LTO },
+	{ AMOVB,		C_REG,		C_NONE,		C_ADDR,		31,	4,	0,	LTO },
+	{ AMOVHU,	C_REG,		C_NONE,		C_ADDR,		31,	4,	0,	LTO },
+	{ AMOVBU,	C_REG,		C_NONE,		C_ADDR,		31,	4,	0,	LTO },
 
 	{ AXXX,		C_NONE,		C_NONE,		C_NONE,		0,	2,	0 },
 };
@@ -683,7 +671,7 @@ thumbasmout(Prog *p, Optab *o)
 	rt = p->to.reg;
 	r = p->reg;
 	o1 = o2 = o3 = o4 = o5 = o6 = o7 = 0;
-if(debug['P']) print("%ulx: %P	type %d %d\n", (uint32)(p->pc), p, o->type, p->align);
+if(debug['P']) print("%ux: %P	type %d %d\n", (uint32)(p->pc), p, o->type, p->align);
 	opcount[o->type] += o->size;
 	switch(o->type) {
 	default:
@@ -691,7 +679,7 @@ if(debug['P']) print("%ulx: %P	type %d %d\n", (uint32)(p->pc), p, o->type, p->al
 		prasm(p);
 		break;
 	case 0:		/* pseudo ops */
-if(debug['G']) print("%ulx: %s: thumb\n", (uint32)(p->pc), p->from.sym->name);
+if(debug['G']) print("%ux: %s: thumb\n", (uint32)(p->pc), p->from.sym->name);
 		break;
 	case 1:		/* op R, -, R or op R, R, - */
 		o1 = thumboprr(p->as);
@@ -981,6 +969,7 @@ if(debug['G']) print("%ulx: %s: thumb\n", (uint32)(p->pc), p->from.sym->name);
 		}
 		break;
 	case 30:		/* AMOVW... *addr, R */
+		diag("likely broken");  // does this still refer to SB?
 		thumbaclass(&p->from, p);
 		o1 = mv(p, rt, instoffset);		// MOV addr, rtmp
 		o2 = thumbopmv(p->as, 1);
@@ -988,6 +977,7 @@ if(debug['G']) print("%ulx: %s: thumb\n", (uint32)(p->pc), p->from.sym->name);
 		o2 |= (rt<<3) | rt;			// MOV* 0(rtmp), R
 		break;
 	case 31:		/* AMOVW... R, *addr */
+		diag("likely broken");  // does this still refer to SB?
 		thumbaclass(&p->to, p);
 		o1 = mv(p, REGTMPT, instoffset);
 		o2 = thumbopmv(p->as, 0);
@@ -1162,29 +1152,29 @@ if(debug['G']) print("%ulx: %s: thumb\n", (uint32)(p->pc), p->from.sym->name);
 	switch(o->size) {
 	default:
 		if(debug['a'])
-			Bprint(&bso, " %.8lux:\t\t%P\n", v, p);
+			Bprint(&bso, " %.8ux:\t\t%P\n", v, p);
 		break;
 	case 2:
 		if(debug['a'])
-			Bprint(&bso, " %.8lux: %.8lux\t%P\n", v, o1, p);
+			Bprint(&bso, " %.8ux: %.8ux\t%P\n", v, o1, p);
 		hputl(o1);
 		break;
 	case 4:
 		if(debug['a'])
-			Bprint(&bso, " %.8lux: %.8lux %.8lux\t%P\n", v, o1, o2, p);
+			Bprint(&bso, " %.8ux: %.8ux %.8ux\t%P\n", v, o1, o2, p);
 		hputl(o1);
 		hputl(o2);
 		break;
 	case 6:
 		if(debug['a'])
-			Bprint(&bso, "%.8lux: %.8lux %.8lux %.8lux\t%P\n", v, o1, o2, o3, p);
+			Bprint(&bso, "%.8ux: %.8ux %.8ux %.8ux\t%P\n", v, o1, o2, o3, p);
 		hputl(o1);
 		hputl(o2);
 		hputl(o3);
 		break;
 	case 8:
 		if(debug['a'])
-			Bprint(&bso, "%.8lux: %.8lux %.8lux %.8lux %.8lux\t%P\n", v, o1, o2, o3, o4, p);
+			Bprint(&bso, "%.8ux: %.8ux %.8ux %.8ux %.8ux\t%P\n", v, o1, o2, o3, o4, p);
 		hputl(o1);
 		hputl(o2);
 		hputl(o3);
@@ -1192,7 +1182,7 @@ if(debug['G']) print("%ulx: %s: thumb\n", (uint32)(p->pc), p->from.sym->name);
 		break;
 	case 10:
 		if(debug['a'])
-			Bprint(&bso, "%.8lux: %.8lux %.8lux %.8lux %.8lux %.8lux\t%P\n", v, o1, o2, o3, o4, o5, p);
+			Bprint(&bso, "%.8ux: %.8ux %.8ux %.8ux %.8ux %.8ux\t%P\n", v, o1, o2, o3, o4, o5, p);
 		hputl(o1);
 		hputl(o2);
 		hputl(o3);
@@ -1201,7 +1191,7 @@ if(debug['G']) print("%ulx: %s: thumb\n", (uint32)(p->pc), p->from.sym->name);
 		break;
 	case 12:
 		if(debug['a'])
-			Bprint(&bso, "%.8lux: %.8lux %.8lux %.8lux %.8lux %.8lux %.8lux\t%P\n", v, o1, o2, o3, o4, o5, o6, p);
+			Bprint(&bso, "%.8ux: %.8ux %.8ux %.8ux %.8ux %.8ux %.8ux\t%P\n", v, o1, o2, o3, o4, o5, o6, p);
 		hputl(o1);
 		hputl(o2);
 		hputl(o3);
@@ -1211,7 +1201,7 @@ if(debug['G']) print("%ulx: %s: thumb\n", (uint32)(p->pc), p->from.sym->name);
 		break;
 	case 14:
 		if(debug['a'])
-			Bprint(&bso, "%.8lux: %.8lux %.8lux %.8lux %.8lux %.8lux %.8lux %.8lux\t%P\n", v, o1, o2, o3, o4, o5, o6, o7, p);
+			Bprint(&bso, "%.8ux: %.8ux %.8ux %.8ux %.8ux %.8ux %.8ux %.8ux\t%P\n", v, o1, o2, o3, o4, o5, o6, o7, p);
 		hputl(o1);
 		hputl(o2);
 		hputl(o3);
@@ -1223,12 +1213,12 @@ if(debug['G']) print("%ulx: %s: thumb\n", (uint32)(p->pc), p->from.sym->name);
 	}
 	if(debug['G']){
 		if(o->type == 17){
-			print("%lx:	word %ld\n", p->pc, (o2<<16)+o1);
+			print("%x:	word %d\n", p->pc, (o2<<16)+o1);
 			return;
 		}
 		if(o->type == 50){
-			print("%lx:	word %ld\n", p->pc, (o2<<16)+o1);
-			print("%lx:	word %ld\n", p->pc, (o4<<16)+o3);
+			print("%x:	word %d\n", p->pc, (o2<<16)+o1);
+			print("%x:	word %d\n", p->pc, (o4<<16)+o3);
 			return;
 		}
 		if(o->size > 0) dis(o1, p->pc);