src/cmd/5l/noop.c - go - Git at Google

 // Inferno utils/5l/noop.c
 // http://code.google.com/p/inferno-os/source/browse/utils/5l/noop.c
 //
 //	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
 //	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
 //	Portions Copyright © 1997-1999 Vita Nuova Limited
 //	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
 //	Portions Copyright © 2004,2006 Bruce Ellis
 //	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
 //	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
 //	Portions Copyright © 2009 The Go Authors.  All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in
 // all copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.

 #include	"l.h"

 // see ../../runtime/proc.c:/StackGuard
 enum
 {
 	StackBig = 4096,
 };

 static	Sym*	sym_div;
 static	Sym*	sym_divu;
 static	Sym*	sym_mod;
 static	Sym*	sym_modu;

 static void setdiv(int);

 static Prog *
 movrr(Prog *q, int rs, int rd, Prog *p)
 {
 	if(q == nil)
 		q = prg();
 	q->as = AMOVW;
 	q->line = p->line;
 	q->from.type = D_REG;
 	q->from.reg = rs;
 	q->to.type = D_REG;
 	q->to.reg = rd;
 	q->link = p->link;
 	return q;
 }

 static Prog *
 fnret(Prog *q, int rs, int foreign, Prog *p)
 {
 	q = movrr(q, rs, REGPC, p);
 	if(foreign){	// BX rs
 		q->as = ABXRET;
 		q->from.type = D_NONE;
 		q->from.reg = NREG;
 		q->to.reg = rs;
 	}
 	return q;
 }

 static Prog *
 aword(int32 w, Prog *p)
 {
 	Prog *q;

 	q = prg();
 	q->as = AWORD;
 	q->line = p->line;
 	q->from.type = D_NONE;
 	q->reg = NREG;
 	q->to.type = D_CONST;
 	q->to.offset = w;
 	q->link = p->link;
 	p->link = q;
 	return q;
 }

 static Prog *
 adword(int32 w1, int32 w2, Prog *p)
 {
 	Prog *q;

 	q = prg();
 	q->as = ADWORD;
 	q->line = p->line;
 	q->from.type = D_CONST;
 	q->from.offset = w1;
 	q->reg = NREG;
 	q->to.type = D_CONST;
 	q->to.offset = w2;
 	q->link = p->link;
 	p->link = q;
 	return q;
 }

 void
 noops(void)
 {
 	Prog *p, *q, *q1, *q2;
 	int o, curframe, curbecome, maxbecome, foreign;
 	Prog *pmorestack;
 	Sym *symmorestack;

 	/*
 	 * find leaf subroutines
 	 * become sizes
 	 * frame sizes
 	 * strip NOPs
 	 * expand RET
 	 * expand BECOME pseudo
 	 */

 	if(debug['v'])
 		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;
 			}
 		}
 	}
 	// TODO(kaib): make lack of morestack an error
 //	if(pmorestack == P)
 //		diag("runtime·morestack not defined");

 	curframe = 0;
 	curbecome = 0;
 	maxbecome = 0;
 	curtext = 0;

 	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);
 					}
 				}
 			}
 			break;
 		}
 	}

 	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;
 			}
 #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
 			}
 #endif
 			if(curtext->mark & LEAF) {
 				if(curtext->from.sym)
 					curtext->from.sym->type = SLEAF;
 				if(!autosize)
 					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;
 					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(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);
 						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;
 						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 = 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;
 				}
 				break;
 			}
 			if(foreign) {
 // if(foreign) print("ABXRET 3 %s\n", curtext->from.sym->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 = 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;

 		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;
 					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;
 				p->as = AMOVW;
 				p->line = p->line;
 				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;
 				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;
 				break;
 			case AMODU:
 				p->cond = prog_modu;
 				p->to.sym = sym_modu;
 				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;
 				}
 				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 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;
 				}
 			}
 			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;
 				}
 				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;
 		}
 	}
 }

 static void
 sigdiv(char *n)
 {
 	Sym *s;

 	s = lookup(n, 0);
 	if(s->type == STEXT){
 		if(s->sig == 0)
 			s->sig = SIGNINTERN;
 	}
 	else if(s->type == 0 || s->type == SXREF)
 		s->type = SUNDEF;
 }

 void
 divsig(void)
 {
 	sigdiv("_div");
 	sigdiv("_divu");
 	sigdiv("_mod");
 	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;
 	sym_div = s2 = lookup("_div", 0);
 	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;
 		}
 	if(prog_div == P) {
 		diag("undefined: %s", s2->name);
 		prog_div = curtext;
 	}
 	if(prog_divu == P) {
 		diag("undefined: %s", s3->name);
 		prog_divu = curtext;
 	}
 	if(prog_mod == P) {
 		diag("undefined: %s", s4->name);
 		prog_mod = curtext;
 	}
 	if(prog_modu == P) {
 		diag("undefined: %s", s5->name);
 		prog_modu = curtext;
 	}
 }

 static void
 setdiv(int as)
 {
 	Prog *p = nil;

 	switch(as){
 	case ADIV: p = prog_div; break;
 	case ADIVU: p = prog_divu; break;
 	case AMOD: p = prog_mod; break;
 	case AMODU: p = prog_modu; break;
 	}
 	if(p != UP && thumb != p->from.sym->thumb)
 		p->from.sym->foreign = 1;
 }

 void
 nocache(Prog *p)
 {
 	p->optab = 0;
 	p->from.class = 0;
 	p->to.class = 0;
 }
	// Inferno utils/5l/noop.c
	// http://code.google.com/p/inferno-os/source/browse/utils/5l/noop.c
	//
	// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
	// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
	// Portions Copyright © 1997-1999 Vita Nuova Limited
	// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
	// Portions Copyright © 2004,2006 Bruce Ellis
	// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
	// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
	// Portions Copyright © 2009 The Go Authors. All rights reserved.
	//
	// Permission is hereby granted, free of charge, to any person obtaining a copy
	// of this software and associated documentation files (the "Software"), to deal
	// in the Software without restriction, including without limitation the rights
	// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	// copies of the Software, and to permit persons to whom the Software is
	// furnished to do so, subject to the following conditions:
	//
	// The above copyright notice and this permission notice shall be included in
	// all copies or substantial portions of the Software.
	//
	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	// THE SOFTWARE.

	#include "l.h"

	// see ../../runtime/proc.c:/StackGuard
	enum
	{
	StackBig = 4096,
	};

	static Sym* sym_div;
	static Sym* sym_divu;
	static Sym* sym_mod;
	static Sym* sym_modu;

	static void setdiv(int);

	static Prog *
	movrr(Prog q, int rs, int rd, Prog p)
	{
	if(q == nil)
	q = prg();
	q->as = AMOVW;
	q->line = p->line;
	q->from.type = D_REG;
	q->from.reg = rs;
	q->to.type = D_REG;
	q->to.reg = rd;
	q->link = p->link;
	return q;
	}

	static Prog *
	fnret(Prog q, int rs, int foreign, Prog p)
	{
	q = movrr(q, rs, REGPC, p);
	if(foreign){ // BX rs
	q->as = ABXRET;
	q->from.type = D_NONE;
	q->from.reg = NREG;
	q->to.reg = rs;
	}
	return q;
	}

	static Prog *
	aword(int32 w, Prog *p)
	{
	Prog *q;

	q = prg();
	q->as = AWORD;
	q->line = p->line;
	q->from.type = D_NONE;
	q->reg = NREG;
	q->to.type = D_CONST;
	q->to.offset = w;
	q->link = p->link;
	p->link = q;
	return q;
	}

	static Prog *
	adword(int32 w1, int32 w2, Prog *p)
	{
	Prog *q;

	q = prg();
	q->as = ADWORD;
	q->line = p->line;
	q->from.type = D_CONST;
	q->from.offset = w1;
	q->reg = NREG;
	q->to.type = D_CONST;
	q->to.offset = w2;
	q->link = p->link;
	p->link = q;
	return q;
	}

	void
	noops(void)
	{
	Prog p, q, q1, q2;
	int o, curframe, curbecome, maxbecome, foreign;
	Prog *pmorestack;
	Sym *symmorestack;

	/*
	* find leaf subroutines
	* become sizes
	* frame sizes
	* strip NOPs
	* expand RET
	* expand BECOME pseudo
	*/

	if(debug['v'])
	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;
	}
	}
	}
	// TODO(kaib): make lack of morestack an error
	// if(pmorestack == P)
	// diag("runtime·morestack not defined");

	curframe = 0;
	curbecome = 0;
	maxbecome = 0;
	curtext = 0;

	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);
	}
	}
	}
	break;
	}
	}

	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;
	}
	#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
	}
	#endif
	if(curtext->mark & LEAF) {
	if(curtext->from.sym)
	curtext->from.sym->type = SLEAF;
	if(!autosize)
	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;
	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(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);
	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;
	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 = 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;
	}
	break;
	}
	if(foreign) {
	// if(foreign) print("ABXRET 3 %s\n", curtext->from.sym->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 = 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;

	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;
	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;
	p->as = AMOVW;
	p->line = p->line;
	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;
	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;
	break;
	case AMODU:
	p->cond = prog_modu;
	p->to.sym = sym_modu;
	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;
	}
	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 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;
	}
	}
	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;
	}
	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;
	}
	}
	}

	static void
	sigdiv(char *n)
	{
	Sym *s;

	s = lookup(n, 0);
	if(s->type == STEXT){
	if(s->sig == 0)
	s->sig = SIGNINTERN;
	}
	else if(s->type == 0 \|\| s->type == SXREF)
	s->type = SUNDEF;
	}

	void
	divsig(void)
	{
	sigdiv("_div");
	sigdiv("_divu");
	sigdiv("_mod");
	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;
	sym_div = s2 = lookup("_div", 0);
	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;
	}
	if(prog_div == P) {
	diag("undefined: %s", s2->name);
	prog_div = curtext;
	}
	if(prog_divu == P) {
	diag("undefined: %s", s3->name);
	prog_divu = curtext;
	}
	if(prog_mod == P) {
	diag("undefined: %s", s4->name);
	prog_mod = curtext;
	}
	if(prog_modu == P) {
	diag("undefined: %s", s5->name);
	prog_modu = curtext;
	}
	}

	static void
	setdiv(int as)
	{
	Prog *p = nil;

	switch(as){
	case ADIV: p = prog_div; break;
	case ADIVU: p = prog_divu; break;
	case AMOD: p = prog_mod; break;
	case AMODU: p = prog_modu; break;
	}
	if(p != UP && thumb != p->from.sym->thumb)
	p->from.sym->foreign = 1;
	}

	void
	nocache(Prog *p)
	{
	p->optab = 0;
	p->from.class = 0;
	p->to.class = 0;
	}