src/cmd/internal/obj/arm/obj5.go - go - Git at Google

 // Derived from Inferno utils/5c/swt.c
 // https://bitbucket.org/inferno-os/inferno-os/src/default/utils/5c/swt.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.

 package arm

 import (
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
 )

 var progedit_tlsfallback *obj.LSym

 func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
 	p.From.Class = 0
 	p.To.Class = 0

 	c := ctxt5{ctxt: ctxt, newprog: newprog}

 	// Rewrite B/BL to symbol as TYPE_BRANCH.
 	switch p.As {
 	case AB, ABL, obj.ADUFFZERO, obj.ADUFFCOPY:
 		if p.To.Type == obj.TYPE_MEM && (p.To.Name == obj.NAME_EXTERN || p.To.Name == obj.NAME_STATIC) && p.To.Sym != nil {
 			p.To.Type = obj.TYPE_BRANCH
 		}
 	}

 	// Replace TLS register fetches on older ARM processors.
 	switch p.As {
 	// Treat MRC 15, 0, <reg>, C13, C0, 3 specially.
 	case AMRC:
 		if p.To.Offset&0xffff0fff == 0xee1d0f70 {
 			// Because the instruction might be rewritten to a BL which returns in R0
 			// the register must be zero.
 			if p.To.Offset&0xf000 != 0 {
 				ctxt.Diag("%v: TLS MRC instruction must write to R0 as it might get translated into a BL instruction", p.Line())
 			}

 			if objabi.GOARM < 7 {
 				// Replace it with BL runtime.read_tls_fallback(SB) for ARM CPUs that lack the tls extension.
 				if progedit_tlsfallback == nil {
 					progedit_tlsfallback = ctxt.Lookup("runtime.read_tls_fallback")
 				}

 				// MOVW	LR, R11
 				p.As = AMOVW

 				p.From.Type = obj.TYPE_REG
 				p.From.Reg = REGLINK
 				p.To.Type = obj.TYPE_REG
 				p.To.Reg = REGTMP

 				// BL	runtime.read_tls_fallback(SB)
 				p = obj.Appendp(p, newprog)

 				p.As = ABL
 				p.To.Type = obj.TYPE_BRANCH
 				p.To.Sym = progedit_tlsfallback
 				p.To.Offset = 0

 				// MOVW	R11, LR
 				p = obj.Appendp(p, newprog)

 				p.As = AMOVW
 				p.From.Type = obj.TYPE_REG
 				p.From.Reg = REGTMP
 				p.To.Type = obj.TYPE_REG
 				p.To.Reg = REGLINK
 				break
 			}
 		}

 		// Otherwise, MRC/MCR instructions need no further treatment.
 		p.As = AWORD
 	}

 	// Rewrite float constants to values stored in memory.
 	switch p.As {
 	case AMOVF:
 		if p.From.Type == obj.TYPE_FCONST && c.chipfloat5(p.From.Val.(float64)) < 0 && (c.chipzero5(p.From.Val.(float64)) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
 			f32 := float32(p.From.Val.(float64))
 			p.From.Type = obj.TYPE_MEM
 			p.From.Sym = ctxt.Float32Sym(f32)
 			p.From.Name = obj.NAME_EXTERN
 			p.From.Offset = 0
 		}

 	case AMOVD:
 		if p.From.Type == obj.TYPE_FCONST && c.chipfloat5(p.From.Val.(float64)) < 0 && (c.chipzero5(p.From.Val.(float64)) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
 			p.From.Type = obj.TYPE_MEM
 			p.From.Sym = ctxt.Float64Sym(p.From.Val.(float64))
 			p.From.Name = obj.NAME_EXTERN
 			p.From.Offset = 0
 		}
 	}

 	if ctxt.Flag_dynlink {
 		c.rewriteToUseGot(p)
 	}
 }

 // Rewrite p, if necessary, to access global data via the global offset table.
 func (c *ctxt5) rewriteToUseGot(p *obj.Prog) {
 	if p.As == obj.ADUFFCOPY || p.As == obj.ADUFFZERO {
 		//     ADUFFxxx $offset
 		// becomes
 		//     MOVW runtime.duffxxx@GOT, R9
 		//     ADD $offset, R9
 		//     CALL (R9)
 		var sym *obj.LSym
 		if p.As == obj.ADUFFZERO {
 			sym = c.ctxt.Lookup("runtime.duffzero")
 		} else {
 			sym = c.ctxt.Lookup("runtime.duffcopy")
 		}
 		offset := p.To.Offset
 		p.As = AMOVW
 		p.From.Type = obj.TYPE_MEM
 		p.From.Name = obj.NAME_GOTREF
 		p.From.Sym = sym
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = REG_R9
 		p.To.Name = obj.NAME_NONE
 		p.To.Offset = 0
 		p.To.Sym = nil
 		p1 := obj.Appendp(p, c.newprog)
 		p1.As = AADD
 		p1.From.Type = obj.TYPE_CONST
 		p1.From.Offset = offset
 		p1.To.Type = obj.TYPE_REG
 		p1.To.Reg = REG_R9
 		p2 := obj.Appendp(p1, c.newprog)
 		p2.As = obj.ACALL
 		p2.To.Type = obj.TYPE_MEM
 		p2.To.Reg = REG_R9
 		return
 	}

 	// We only care about global data: NAME_EXTERN means a global
 	// symbol in the Go sense, and p.Sym.Local is true for a few
 	// internally defined symbols.
 	if p.From.Type == obj.TYPE_ADDR && p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
 		// MOVW $sym, Rx becomes MOVW sym@GOT, Rx
 		// MOVW $sym+<off>, Rx becomes MOVW sym@GOT, Rx; ADD <off>, Rx
 		if p.As != AMOVW {
 			c.ctxt.Diag("do not know how to handle TYPE_ADDR in %v with -dynlink", p)
 		}
 		if p.To.Type != obj.TYPE_REG {
 			c.ctxt.Diag("do not know how to handle LEAQ-type insn to non-register in %v with -dynlink", p)
 		}
 		p.From.Type = obj.TYPE_MEM
 		p.From.Name = obj.NAME_GOTREF
 		if p.From.Offset != 0 {
 			q := obj.Appendp(p, c.newprog)
 			q.As = AADD
 			q.From.Type = obj.TYPE_CONST
 			q.From.Offset = p.From.Offset
 			q.To = p.To
 			p.From.Offset = 0
 		}
 	}
 	if p.GetFrom3() != nil && p.GetFrom3().Name == obj.NAME_EXTERN {
 		c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
 	}
 	var source *obj.Addr
 	// MOVx sym, Ry becomes MOVW sym@GOT, R9; MOVx (R9), Ry
 	// MOVx Ry, sym becomes MOVW sym@GOT, R9; MOVx Ry, (R9)
 	// An addition may be inserted between the two MOVs if there is an offset.
 	if p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
 		if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
 			c.ctxt.Diag("cannot handle NAME_EXTERN on both sides in %v with -dynlink", p)
 		}
 		source = &p.From
 	} else if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
 		source = &p.To
 	} else {
 		return
 	}
 	if p.As == obj.ATEXT || p.As == obj.AFUNCDATA || p.As == obj.ACALL || p.As == obj.ARET || p.As == obj.AJMP {
 		return
 	}
 	if source.Sym.Type == objabi.STLSBSS {
 		return
 	}
 	if source.Type != obj.TYPE_MEM {
 		c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
 	}
 	p1 := obj.Appendp(p, c.newprog)
 	p2 := obj.Appendp(p1, c.newprog)

 	p1.As = AMOVW
 	p1.From.Type = obj.TYPE_MEM
 	p1.From.Sym = source.Sym
 	p1.From.Name = obj.NAME_GOTREF
 	p1.To.Type = obj.TYPE_REG
 	p1.To.Reg = REG_R9

 	p2.As = p.As
 	p2.From = p.From
 	p2.To = p.To
 	if p.From.Name == obj.NAME_EXTERN {
 		p2.From.Reg = REG_R9
 		p2.From.Name = obj.NAME_NONE
 		p2.From.Sym = nil
 	} else if p.To.Name == obj.NAME_EXTERN {
 		p2.To.Reg = REG_R9
 		p2.To.Name = obj.NAME_NONE
 		p2.To.Sym = nil
 	} else {
 		return
 	}
 	obj.Nopout(p)
 }

 // Prog.mark
 const (
 	FOLL  = 1 << 0
 	LABEL = 1 << 1
 	LEAF  = 1 << 2
 )

 func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 	autosize := int32(0)

 	if cursym.Func.Text == nil || cursym.Func.Text.Link == nil {
 		return
 	}

 	c := ctxt5{ctxt: ctxt, cursym: cursym, newprog: newprog}

 	p := c.cursym.Func.Text
 	autoffset := int32(p.To.Offset)
 	if autoffset == -4 {
 		// Historical way to mark NOFRAME.
 		p.From.Sym.Set(obj.AttrNoFrame, true)
 		autoffset = 0
 	}
 	if autoffset < 0 || autoffset%4 != 0 {
 		c.ctxt.Diag("frame size %d not 0 or a positive multiple of 4", autoffset)
 	}
 	if p.From.Sym.NoFrame() {
 		if autoffset != 0 {
 			c.ctxt.Diag("NOFRAME functions must have a frame size of 0, not %d", autoffset)
 		}
 	}

 	cursym.Func.Locals = autoffset
 	cursym.Func.Args = p.To.Val.(int32)

 	/*
 	 * find leaf subroutines
 	 * strip NOPs
 	 * expand RET
 	 * expand BECOME pseudo
 	 */
 	var q1 *obj.Prog
 	var q *obj.Prog
 	for p := cursym.Func.Text; p != nil; p = p.Link {
 		switch p.As {
 		case obj.ATEXT:
 			p.Mark |= LEAF

 		case obj.ARET:
 			break

 		case ADIV, ADIVU, AMOD, AMODU:
 			q = p
 			cursym.Func.Text.Mark &^= LEAF
 			continue

 		case obj.ANOP:
 			q1 = p.Link
 			q.Link = q1 /* q is non-nop */
 			if q1 != nil {
 				q1.Mark |= p.Mark
 			}
 			continue

 		case ABL,
 			ABX,
 			obj.ADUFFZERO,
 			obj.ADUFFCOPY:
 			cursym.Func.Text.Mark &^= LEAF
 			fallthrough

 		case AB,
 			ABEQ,
 			ABNE,
 			ABCS,
 			ABHS,
 			ABCC,
 			ABLO,
 			ABMI,
 			ABPL,
 			ABVS,
 			ABVC,
 			ABHI,
 			ABLS,
 			ABGE,
 			ABLT,
 			ABGT,
 			ABLE:
 			q1 = p.Pcond
 			if q1 != nil {
 				for q1.As == obj.ANOP {
 					q1 = q1.Link
 					p.Pcond = q1
 				}
 			}
 		}

 		q = p
 	}

 	var q2 *obj.Prog
 	for p := cursym.Func.Text; p != nil; p = p.Link {
 		o := p.As
 		switch o {
 		case obj.ATEXT:
 			autosize = autoffset

 			if p.Mark&LEAF != 0 && autosize == 0 {
 				// A leaf function with no locals has no frame.
 				p.From.Sym.Set(obj.AttrNoFrame, true)
 			}

 			if !p.From.Sym.NoFrame() {
 				// If there is a stack frame at all, it includes
 				// space to save the LR.
 				autosize += 4
 			}

 			if autosize == 0 && cursym.Func.Text.Mark&LEAF == 0 {
 				// A very few functions that do not return to their caller
 				// are not identified as leaves but still have no frame.
 				if ctxt.Debugvlog {
 					ctxt.Logf("save suppressed in: %s\n", cursym.Name)
 				}

 				cursym.Func.Text.Mark |= LEAF
 			}

 			// FP offsets need an updated p.To.Offset.
 			p.To.Offset = int64(autosize) - 4

 			if cursym.Func.Text.Mark&LEAF != 0 {
 				cursym.Set(obj.AttrLeaf, true)
 				if p.From.Sym.NoFrame() {
 					break
 				}
 			}

 			if !p.From.Sym.NoSplit() {
 				p = c.stacksplit(p, autosize) // emit split check
 			}

 			// MOVW.W		R14,$-autosize(SP)
 			p = obj.Appendp(p, c.newprog)

 			p.As = AMOVW
 			p.Scond |= C_WBIT
 			p.From.Type = obj.TYPE_REG
 			p.From.Reg = REGLINK
 			p.To.Type = obj.TYPE_MEM
 			p.To.Offset = int64(-autosize)
 			p.To.Reg = REGSP
 			p.Spadj = autosize

 			if cursym.Func.Text.From.Sym.Wrapper() {
 				// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
 				//
 				//	MOVW g_panic(g), R1
 				//	CMP  $0, R1
 				//	B.NE checkargp
 				// end:
 				//	NOP
 				// ... function ...
 				// checkargp:
 				//	MOVW panic_argp(R1), R2
 				//	ADD  $(autosize+4), R13, R3
 				//	CMP  R2, R3
 				//	B.NE end
 				//	ADD  $4, R13, R4
 				//	MOVW R4, panic_argp(R1)
 				//	B    end
 				//
 				// The NOP is needed to give the jumps somewhere to land.
 				// It is a liblink NOP, not an ARM NOP: it encodes to 0 instruction bytes.

 				p = obj.Appendp(p, newprog)
 				p.As = AMOVW
 				p.From.Type = obj.TYPE_MEM
 				p.From.Reg = REGG
 				p.From.Offset = 4 * int64(ctxt.Arch.PtrSize) // G.panic
 				p.To.Type = obj.TYPE_REG
 				p.To.Reg = REG_R1

 				p = obj.Appendp(p, newprog)
 				p.As = ACMP
 				p.From.Type = obj.TYPE_CONST
 				p.From.Offset = 0
 				p.Reg = REG_R1

 				// B.NE checkargp
 				bne := obj.Appendp(p, newprog)
 				bne.As = ABNE
 				bne.To.Type = obj.TYPE_BRANCH

 				// end: NOP
 				end := obj.Appendp(bne, newprog)
 				end.As = obj.ANOP

 				// find end of function
 				var last *obj.Prog
 				for last = end; last.Link != nil; last = last.Link {
 				}

 				// MOVW panic_argp(R1), R2
 				mov := obj.Appendp(last, newprog)
 				mov.As = AMOVW
 				mov.From.Type = obj.TYPE_MEM
 				mov.From.Reg = REG_R1
 				mov.From.Offset = 0 // Panic.argp
 				mov.To.Type = obj.TYPE_REG
 				mov.To.Reg = REG_R2

 				// B.NE branch target is MOVW above
 				bne.Pcond = mov

 				// ADD $(autosize+4), R13, R3
 				p = obj.Appendp(mov, newprog)
 				p.As = AADD
 				p.From.Type = obj.TYPE_CONST
 				p.From.Offset = int64(autosize) + 4
 				p.Reg = REG_R13
 				p.To.Type = obj.TYPE_REG
 				p.To.Reg = REG_R3

 				// CMP R2, R3
 				p = obj.Appendp(p, newprog)
 				p.As = ACMP
 				p.From.Type = obj.TYPE_REG
 				p.From.Reg = REG_R2
 				p.Reg = REG_R3

 				// B.NE end
 				p = obj.Appendp(p, newprog)
 				p.As = ABNE
 				p.To.Type = obj.TYPE_BRANCH
 				p.Pcond = end

 				// ADD $4, R13, R4
 				p = obj.Appendp(p, newprog)
 				p.As = AADD
 				p.From.Type = obj.TYPE_CONST
 				p.From.Offset = 4
 				p.Reg = REG_R13
 				p.To.Type = obj.TYPE_REG
 				p.To.Reg = REG_R4

 				// MOVW R4, panic_argp(R1)
 				p = obj.Appendp(p, newprog)
 				p.As = AMOVW
 				p.From.Type = obj.TYPE_REG
 				p.From.Reg = REG_R4
 				p.To.Type = obj.TYPE_MEM
 				p.To.Reg = REG_R1
 				p.To.Offset = 0 // Panic.argp

 				// B end
 				p = obj.Appendp(p, newprog)
 				p.As = AB
 				p.To.Type = obj.TYPE_BRANCH
 				p.Pcond = end

 				// reset for subsequent passes
 				p = end
 			}

 		case obj.ARET:
 			nocache(p)
 			if cursym.Func.Text.Mark&LEAF != 0 {
 				if autosize == 0 {
 					p.As = AB
 					p.From = obj.Addr{}
 					if p.To.Sym != nil { // retjmp
 						p.To.Type = obj.TYPE_BRANCH
 					} else {
 						p.To.Type = obj.TYPE_MEM
 						p.To.Offset = 0
 						p.To.Reg = REGLINK
 					}

 					break
 				}
 			}

 			p.As = AMOVW
 			p.Scond |= C_PBIT
 			p.From.Type = obj.TYPE_MEM
 			p.From.Offset = int64(autosize)
 			p.From.Reg = REGSP
 			p.To.Type = obj.TYPE_REG
 			p.To.Reg = REGPC

 			// If there are instructions following
 			// this ARET, they come from a branch
 			// with the same stackframe, so no spadj.
 			if p.To.Sym != nil { // retjmp
 				p.To.Reg = REGLINK
 				q2 = obj.Appendp(p, newprog)
 				q2.As = AB
 				q2.To.Type = obj.TYPE_BRANCH
 				q2.To.Sym = p.To.Sym
 				p.To.Sym = nil
 				p = q2
 			}

 		case AADD:
 			if p.From.Type == obj.TYPE_CONST && p.From.Reg == 0 && p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP {
 				p.Spadj = int32(-p.From.Offset)
 			}

 		case ASUB:
 			if p.From.Type == obj.TYPE_CONST && p.From.Reg == 0 && p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP {
 				p.Spadj = int32(p.From.Offset)
 			}

 		case ADIV, ADIVU, AMOD, AMODU:
 			if cursym.Func.Text.From.Sym.NoSplit() {
 				ctxt.Diag("cannot divide in NOSPLIT function")
 			}
 			const debugdivmod = false
 			if debugdivmod {
 				break
 			}
 			if p.From.Type != obj.TYPE_REG {
 				break
 			}
 			if p.To.Type != obj.TYPE_REG {
 				break
 			}

 			// Make copy because we overwrite p below.
 			q1 := *p
 			if q1.Reg == REGTMP || q1.Reg == 0 && q1.To.Reg == REGTMP {
 				ctxt.Diag("div already using REGTMP: %v", p)
 			}

 			/* MOV m(g),REGTMP */
 			p.As = AMOVW
 			p.Pos = q1.Pos
 			p.From.Type = obj.TYPE_MEM
 			p.From.Reg = REGG
 			p.From.Offset = 6 * 4 // offset of g.m
 			p.Reg = 0
 			p.To.Type = obj.TYPE_REG
 			p.To.Reg = REGTMP

 			/* MOV a,m_divmod(REGTMP) */
 			p = obj.Appendp(p, newprog)
 			p.As = AMOVW
 			p.Pos = q1.Pos
 			p.From.Type = obj.TYPE_REG
 			p.From.Reg = q1.From.Reg
 			p.To.Type = obj.TYPE_MEM
 			p.To.Reg = REGTMP
 			p.To.Offset = 8 * 4 // offset of m.divmod

 			/* MOV b, R8 */
 			p = obj.Appendp(p, newprog)
 			p.As = AMOVW
 			p.Pos = q1.Pos
 			p.From.Type = obj.TYPE_REG
 			p.From.Reg = q1.Reg
 			if q1.Reg == 0 {
 				p.From.Reg = q1.To.Reg
 			}
 			p.To.Type = obj.TYPE_REG
 			p.To.Reg = REG_R8
 			p.To.Offset = 0

 			/* CALL appropriate */
 			p = obj.Appendp(p, newprog)
 			p.As = ABL
 			p.Pos = q1.Pos
 			p.To.Type = obj.TYPE_BRANCH
 			switch o {
 			case ADIV:
 				p.To.Sym = symdiv
 			case ADIVU:
 				p.To.Sym = symdivu
 			case AMOD:
 				p.To.Sym = symmod
 			case AMODU:
 				p.To.Sym = symmodu
 			}

 			/* MOV REGTMP, b */
 			p = obj.Appendp(p, newprog)
 			p.As = AMOVW
 			p.Pos = q1.Pos
 			p.From.Type = obj.TYPE_REG
 			p.From.Reg = REGTMP
 			p.From.Offset = 0
 			p.To.Type = obj.TYPE_REG
 			p.To.Reg = q1.To.Reg

 		case AMOVW:
 			if (p.Scond&C_WBIT != 0) && p.To.Type == obj.TYPE_MEM && p.To.Reg == REGSP {
 				p.Spadj = int32(-p.To.Offset)
 			}
 			if (p.Scond&C_PBIT != 0) && p.From.Type == obj.TYPE_MEM && p.From.Reg == REGSP && p.To.Reg != REGPC {
 				p.Spadj = int32(-p.From.Offset)
 			}
 			if p.From.Type == obj.TYPE_ADDR && p.From.Reg == REGSP && p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP {
 				p.Spadj = int32(-p.From.Offset)
 			}

 		case obj.AGETCALLERPC:
 			if cursym.Leaf() {
 				/* MOVW LR, Rd */
 				p.As = AMOVW
 				p.From.Type = obj.TYPE_REG
 				p.From.Reg = REGLINK
 			} else {
 				/* MOVW (RSP), Rd */
 				p.As = AMOVW
 				p.From.Type = obj.TYPE_MEM
 				p.From.Reg = REGSP
 			}
 		}
 	}
 }

 func (c *ctxt5) stacksplit(p *obj.Prog, framesize int32) *obj.Prog {
 	// MOVW g_stackguard(g), R1
 	p = obj.Appendp(p, c.newprog)

 	p.As = AMOVW
 	p.From.Type = obj.TYPE_MEM
 	p.From.Reg = REGG
 	p.From.Offset = 2 * int64(c.ctxt.Arch.PtrSize) // G.stackguard0
 	if c.cursym.CFunc() {
 		p.From.Offset = 3 * int64(c.ctxt.Arch.PtrSize) // G.stackguard1
 	}
 	p.To.Type = obj.TYPE_REG
 	p.To.Reg = REG_R1

 	if framesize <= objabi.StackSmall {
 		// small stack: SP < stackguard
 		//	CMP	stackguard, SP
 		p = obj.Appendp(p, c.newprog)

 		p.As = ACMP
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = REG_R1
 		p.Reg = REGSP
 	} else if framesize <= objabi.StackBig {
 		// large stack: SP-framesize < stackguard-StackSmall
 		//	MOVW $-(framesize-StackSmall)(SP), R2
 		//	CMP stackguard, R2
 		p = obj.Appendp(p, c.newprog)

 		p.As = AMOVW
 		p.From.Type = obj.TYPE_ADDR
 		p.From.Reg = REGSP
 		p.From.Offset = -(int64(framesize) - objabi.StackSmall)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = REG_R2

 		p = obj.Appendp(p, c.newprog)
 		p.As = ACMP
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = REG_R1
 		p.Reg = REG_R2
 	} else {
 		// Such a large stack we need to protect against wraparound
 		// if SP is close to zero.
 		//	SP-stackguard+StackGuard < framesize + (StackGuard-StackSmall)
 		// The +StackGuard on both sides is required to keep the left side positive:
 		// SP is allowed to be slightly below stackguard. See stack.h.
 		//	CMP     $StackPreempt, R1
 		//	MOVW.NE $StackGuard(SP), R2
 		//	SUB.NE  R1, R2
 		//	MOVW.NE $(framesize+(StackGuard-StackSmall)), R3
 		//	CMP.NE  R3, R2
 		p = obj.Appendp(p, c.newprog)

 		p.As = ACMP
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = int64(uint32(objabi.StackPreempt & (1<<32 - 1)))
 		p.Reg = REG_R1

 		p = obj.Appendp(p, c.newprog)
 		p.As = AMOVW
 		p.From.Type = obj.TYPE_ADDR
 		p.From.Reg = REGSP
 		p.From.Offset = int64(objabi.StackGuard)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = REG_R2
 		p.Scond = C_SCOND_NE

 		p = obj.Appendp(p, c.newprog)
 		p.As = ASUB
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = REG_R1
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = REG_R2
 		p.Scond = C_SCOND_NE

 		p = obj.Appendp(p, c.newprog)
 		p.As = AMOVW
 		p.From.Type = obj.TYPE_ADDR
 		p.From.Offset = int64(framesize) + (int64(objabi.StackGuard) - objabi.StackSmall)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = REG_R3
 		p.Scond = C_SCOND_NE

 		p = obj.Appendp(p, c.newprog)
 		p.As = ACMP
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = REG_R3
 		p.Reg = REG_R2
 		p.Scond = C_SCOND_NE
 	}

 	// BLS call-to-morestack
 	bls := obj.Appendp(p, c.newprog)
 	bls.As = ABLS
 	bls.To.Type = obj.TYPE_BRANCH

 	var last *obj.Prog
 	for last = c.cursym.Func.Text; last.Link != nil; last = last.Link {
 	}

 	// Now we are at the end of the function, but logically
 	// we are still in function prologue. We need to fix the
 	// SP data and PCDATA.
 	spfix := obj.Appendp(last, c.newprog)
 	spfix.As = obj.ANOP
 	spfix.Spadj = -framesize

 	pcdata := c.ctxt.EmitEntryLiveness(c.cursym, spfix, c.newprog)

 	// MOVW	LR, R3
 	movw := obj.Appendp(pcdata, c.newprog)
 	movw.As = AMOVW
 	movw.From.Type = obj.TYPE_REG
 	movw.From.Reg = REGLINK
 	movw.To.Type = obj.TYPE_REG
 	movw.To.Reg = REG_R3

 	bls.Pcond = movw

 	// BL runtime.morestack
 	call := obj.Appendp(movw, c.newprog)
 	call.As = obj.ACALL
 	call.To.Type = obj.TYPE_BRANCH
 	morestack := "runtime.morestack"
 	switch {
 	case c.cursym.CFunc():
 		morestack = "runtime.morestackc"
 	case !c.cursym.Func.Text.From.Sym.NeedCtxt():
 		morestack = "runtime.morestack_noctxt"
 	}
 	call.To.Sym = c.ctxt.Lookup(morestack)

 	// B start
 	b := obj.Appendp(call, c.newprog)
 	b.As = obj.AJMP
 	b.To.Type = obj.TYPE_BRANCH
 	b.Pcond = c.cursym.Func.Text.Link
 	b.Spadj = +framesize

 	return bls
 }

 var unaryDst = map[obj.As]bool{
 	ASWI:  true,
 	AWORD: true,
 }

 var Linkarm = obj.LinkArch{
 	Arch:           sys.ArchARM,
 	Init:           buildop,
 	Preprocess:     preprocess,
 	Assemble:       span5,
 	Progedit:       progedit,
 	UnaryDst:       unaryDst,
 	DWARFRegisters: ARMDWARFRegisters,
 }
	// Derived from Inferno utils/5c/swt.c
	// https://bitbucket.org/inferno-os/inferno-os/src/default/utils/5c/swt.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.

	package arm

	import (
	"cmd/internal/obj"
	"cmd/internal/objabi"
	"cmd/internal/sys"
	)

	var progedit_tlsfallback *obj.LSym

	func progedit(ctxt obj.Link, p obj.Prog, newprog obj.ProgAlloc) {
	p.From.Class = 0
	p.To.Class = 0

	c := ctxt5{ctxt: ctxt, newprog: newprog}

	// Rewrite B/BL to symbol as TYPE_BRANCH.
	switch p.As {
	case AB, ABL, obj.ADUFFZERO, obj.ADUFFCOPY:
	if p.To.Type == obj.TYPE_MEM && (p.To.Name == obj.NAME_EXTERN \|\| p.To.Name == obj.NAME_STATIC) && p.To.Sym != nil {
	p.To.Type = obj.TYPE_BRANCH
	}
	}

	// Replace TLS register fetches on older ARM processors.
	switch p.As {
	// Treat MRC 15, 0, <reg>, C13, C0, 3 specially.
	case AMRC:
	if p.To.Offset&0xffff0fff == 0xee1d0f70 {
	// Because the instruction might be rewritten to a BL which returns in R0
	// the register must be zero.
	if p.To.Offset&0xf000 != 0 {
	ctxt.Diag("%v: TLS MRC instruction must write to R0 as it might get translated into a BL instruction", p.Line())
	}

	if objabi.GOARM < 7 {
	// Replace it with BL runtime.read_tls_fallback(SB) for ARM CPUs that lack the tls extension.
	if progedit_tlsfallback == nil {
	progedit_tlsfallback = ctxt.Lookup("runtime.read_tls_fallback")
	}

	// MOVW LR, R11
	p.As = AMOVW

	p.From.Type = obj.TYPE_REG
	p.From.Reg = REGLINK
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REGTMP

	// BL runtime.read_tls_fallback(SB)
	p = obj.Appendp(p, newprog)

	p.As = ABL
	p.To.Type = obj.TYPE_BRANCH
	p.To.Sym = progedit_tlsfallback
	p.To.Offset = 0

	// MOVW R11, LR
	p = obj.Appendp(p, newprog)

	p.As = AMOVW
	p.From.Type = obj.TYPE_REG
	p.From.Reg = REGTMP
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REGLINK
	break
	}
	}

	// Otherwise, MRC/MCR instructions need no further treatment.
	p.As = AWORD
	}

	// Rewrite float constants to values stored in memory.
	switch p.As {
	case AMOVF:
	if p.From.Type == obj.TYPE_FCONST && c.chipfloat5(p.From.Val.(float64)) < 0 && (c.chipzero5(p.From.Val.(float64)) < 0 \|\| p.Scond&C_SCOND != C_SCOND_NONE) {
	f32 := float32(p.From.Val.(float64))
	p.From.Type = obj.TYPE_MEM
	p.From.Sym = ctxt.Float32Sym(f32)
	p.From.Name = obj.NAME_EXTERN
	p.From.Offset = 0
	}

	case AMOVD:
	if p.From.Type == obj.TYPE_FCONST && c.chipfloat5(p.From.Val.(float64)) < 0 && (c.chipzero5(p.From.Val.(float64)) < 0 \|\| p.Scond&C_SCOND != C_SCOND_NONE) {
	p.From.Type = obj.TYPE_MEM
	p.From.Sym = ctxt.Float64Sym(p.From.Val.(float64))
	p.From.Name = obj.NAME_EXTERN
	p.From.Offset = 0
	}
	}

	if ctxt.Flag_dynlink {
	c.rewriteToUseGot(p)
	}
	}

	// Rewrite p, if necessary, to access global data via the global offset table.
	func (c ctxt5) rewriteToUseGot(p obj.Prog) {
	if p.As == obj.ADUFFCOPY \|\| p.As == obj.ADUFFZERO {
	// ADUFFxxx $offset
	// becomes
	// MOVW runtime.duffxxx@GOT, R9
	// ADD $offset, R9
	// CALL (R9)
	var sym *obj.LSym
	if p.As == obj.ADUFFZERO {
	sym = c.ctxt.Lookup("runtime.duffzero")
	} else {
	sym = c.ctxt.Lookup("runtime.duffcopy")
	}
	offset := p.To.Offset
	p.As = AMOVW
	p.From.Type = obj.TYPE_MEM
	p.From.Name = obj.NAME_GOTREF
	p.From.Sym = sym
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REG_R9
	p.To.Name = obj.NAME_NONE
	p.To.Offset = 0
	p.To.Sym = nil
	p1 := obj.Appendp(p, c.newprog)
	p1.As = AADD
	p1.From.Type = obj.TYPE_CONST
	p1.From.Offset = offset
	p1.To.Type = obj.TYPE_REG
	p1.To.Reg = REG_R9
	p2 := obj.Appendp(p1, c.newprog)
	p2.As = obj.ACALL
	p2.To.Type = obj.TYPE_MEM
	p2.To.Reg = REG_R9
	return
	}

	// We only care about global data: NAME_EXTERN means a global
	// symbol in the Go sense, and p.Sym.Local is true for a few
	// internally defined symbols.
	if p.From.Type == obj.TYPE_ADDR && p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
	// MOVW $sym, Rx becomes MOVW sym@GOT, Rx
	// MOVW $sym+<off>, Rx becomes MOVW sym@GOT, Rx; ADD <off>, Rx
	if p.As != AMOVW {
	c.ctxt.Diag("do not know how to handle TYPE_ADDR in %v with -dynlink", p)
	}
	if p.To.Type != obj.TYPE_REG {
	c.ctxt.Diag("do not know how to handle LEAQ-type insn to non-register in %v with -dynlink", p)
	}
	p.From.Type = obj.TYPE_MEM
	p.From.Name = obj.NAME_GOTREF
	if p.From.Offset != 0 {
	q := obj.Appendp(p, c.newprog)
	q.As = AADD
	q.From.Type = obj.TYPE_CONST
	q.From.Offset = p.From.Offset
	q.To = p.To
	p.From.Offset = 0
	}
	}
	if p.GetFrom3() != nil && p.GetFrom3().Name == obj.NAME_EXTERN {
	c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
	}
	var source *obj.Addr
	// MOVx sym, Ry becomes MOVW sym@GOT, R9; MOVx (R9), Ry
	// MOVx Ry, sym becomes MOVW sym@GOT, R9; MOVx Ry, (R9)
	// An addition may be inserted between the two MOVs if there is an offset.
	if p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
	if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
	c.ctxt.Diag("cannot handle NAME_EXTERN on both sides in %v with -dynlink", p)
	}
	source = &p.From
	} else if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
	source = &p.To
	} else {
	return
	}
	if p.As == obj.ATEXT \|\| p.As == obj.AFUNCDATA \|\| p.As == obj.ACALL \|\| p.As == obj.ARET \|\| p.As == obj.AJMP {
	return
	}
	if source.Sym.Type == objabi.STLSBSS {
	return
	}
	if source.Type != obj.TYPE_MEM {
	c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
	}
	p1 := obj.Appendp(p, c.newprog)
	p2 := obj.Appendp(p1, c.newprog)

	p1.As = AMOVW
	p1.From.Type = obj.TYPE_MEM
	p1.From.Sym = source.Sym
	p1.From.Name = obj.NAME_GOTREF
	p1.To.Type = obj.TYPE_REG
	p1.To.Reg = REG_R9

	p2.As = p.As
	p2.From = p.From
	p2.To = p.To
	if p.From.Name == obj.NAME_EXTERN {
	p2.From.Reg = REG_R9
	p2.From.Name = obj.NAME_NONE
	p2.From.Sym = nil
	} else if p.To.Name == obj.NAME_EXTERN {
	p2.To.Reg = REG_R9
	p2.To.Name = obj.NAME_NONE
	p2.To.Sym = nil
	} else {
	return
	}
	obj.Nopout(p)
	}

	// Prog.mark
	const (
	FOLL = 1 << 0
	LABEL = 1 << 1
	LEAF = 1 << 2
	)

	func preprocess(ctxt obj.Link, cursym obj.LSym, newprog obj.ProgAlloc) {
	autosize := int32(0)

	if cursym.Func.Text == nil \|\| cursym.Func.Text.Link == nil {
	return
	}

	c := ctxt5{ctxt: ctxt, cursym: cursym, newprog: newprog}

	p := c.cursym.Func.Text
	autoffset := int32(p.To.Offset)
	if autoffset == -4 {
	// Historical way to mark NOFRAME.
	p.From.Sym.Set(obj.AttrNoFrame, true)
	autoffset = 0
	}
	if autoffset < 0 \|\| autoffset%4 != 0 {
	c.ctxt.Diag("frame size %d not 0 or a positive multiple of 4", autoffset)
	}
	if p.From.Sym.NoFrame() {
	if autoffset != 0 {
	c.ctxt.Diag("NOFRAME functions must have a frame size of 0, not %d", autoffset)
	}
	}

	cursym.Func.Locals = autoffset
	cursym.Func.Args = p.To.Val.(int32)

	/*
	* find leaf subroutines
	* strip NOPs
	* expand RET
	* expand BECOME pseudo
	*/
	var q1 *obj.Prog
	var q *obj.Prog
	for p := cursym.Func.Text; p != nil; p = p.Link {
	switch p.As {
	case obj.ATEXT:
	p.Mark \|= LEAF

	case obj.ARET:
	break

	case ADIV, ADIVU, AMOD, AMODU:
	q = p
	cursym.Func.Text.Mark &^= LEAF
	continue

	case obj.ANOP:
	q1 = p.Link
	q.Link = q1 /* q is non-nop */
	if q1 != nil {
	q1.Mark \|= p.Mark
	}
	continue

	case ABL,
	ABX,
	obj.ADUFFZERO,
	obj.ADUFFCOPY:
	cursym.Func.Text.Mark &^= LEAF
	fallthrough

	case AB,
	ABEQ,
	ABNE,
	ABCS,
	ABHS,
	ABCC,
	ABLO,
	ABMI,
	ABPL,
	ABVS,
	ABVC,
	ABHI,
	ABLS,
	ABGE,
	ABLT,
	ABGT,
	ABLE:
	q1 = p.Pcond
	if q1 != nil {
	for q1.As == obj.ANOP {
	q1 = q1.Link
	p.Pcond = q1
	}
	}
	}

	q = p
	}

	var q2 *obj.Prog
	for p := cursym.Func.Text; p != nil; p = p.Link {
	o := p.As
	switch o {
	case obj.ATEXT:
	autosize = autoffset

	if p.Mark&LEAF != 0 && autosize == 0 {
	// A leaf function with no locals has no frame.
	p.From.Sym.Set(obj.AttrNoFrame, true)
	}

	if !p.From.Sym.NoFrame() {
	// If there is a stack frame at all, it includes
	// space to save the LR.
	autosize += 4
	}

	if autosize == 0 && cursym.Func.Text.Mark&LEAF == 0 {
	// A very few functions that do not return to their caller
	// are not identified as leaves but still have no frame.
	if ctxt.Debugvlog {
	ctxt.Logf("save suppressed in: %s\n", cursym.Name)
	}

	cursym.Func.Text.Mark \|= LEAF
	}

	// FP offsets need an updated p.To.Offset.
	p.To.Offset = int64(autosize) - 4

	if cursym.Func.Text.Mark&LEAF != 0 {
	cursym.Set(obj.AttrLeaf, true)
	if p.From.Sym.NoFrame() {
	break
	}
	}

	if !p.From.Sym.NoSplit() {
	p = c.stacksplit(p, autosize) // emit split check
	}

	// MOVW.W R14,$-autosize(SP)
	p = obj.Appendp(p, c.newprog)

	p.As = AMOVW
	p.Scond \|= C_WBIT
	p.From.Type = obj.TYPE_REG
	p.From.Reg = REGLINK
	p.To.Type = obj.TYPE_MEM
	p.To.Offset = int64(-autosize)
	p.To.Reg = REGSP
	p.Spadj = autosize

	if cursym.Func.Text.From.Sym.Wrapper() {
	// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
	//
	// MOVW g_panic(g), R1
	// CMP $0, R1
	// B.NE checkargp
	// end:
	// NOP
	// ... function ...
	// checkargp:
	// MOVW panic_argp(R1), R2
	// ADD $(autosize+4), R13, R3
	// CMP R2, R3
	// B.NE end
	// ADD $4, R13, R4
	// MOVW R4, panic_argp(R1)
	// B end
	//
	// The NOP is needed to give the jumps somewhere to land.
	// It is a liblink NOP, not an ARM NOP: it encodes to 0 instruction bytes.

	p = obj.Appendp(p, newprog)
	p.As = AMOVW
	p.From.Type = obj.TYPE_MEM
	p.From.Reg = REGG
	p.From.Offset = 4 * int64(ctxt.Arch.PtrSize) // G.panic
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REG_R1

	p = obj.Appendp(p, newprog)
	p.As = ACMP
	p.From.Type = obj.TYPE_CONST
	p.From.Offset = 0
	p.Reg = REG_R1

	// B.NE checkargp
	bne := obj.Appendp(p, newprog)
	bne.As = ABNE
	bne.To.Type = obj.TYPE_BRANCH

	// end: NOP
	end := obj.Appendp(bne, newprog)
	end.As = obj.ANOP

	// find end of function
	var last *obj.Prog
	for last = end; last.Link != nil; last = last.Link {
	}

	// MOVW panic_argp(R1), R2
	mov := obj.Appendp(last, newprog)
	mov.As = AMOVW
	mov.From.Type = obj.TYPE_MEM
	mov.From.Reg = REG_R1
	mov.From.Offset = 0 // Panic.argp
	mov.To.Type = obj.TYPE_REG
	mov.To.Reg = REG_R2

	// B.NE branch target is MOVW above
	bne.Pcond = mov

	// ADD $(autosize+4), R13, R3
	p = obj.Appendp(mov, newprog)
	p.As = AADD
	p.From.Type = obj.TYPE_CONST
	p.From.Offset = int64(autosize) + 4
	p.Reg = REG_R13
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REG_R3

	// CMP R2, R3
	p = obj.Appendp(p, newprog)
	p.As = ACMP
	p.From.Type = obj.TYPE_REG
	p.From.Reg = REG_R2
	p.Reg = REG_R3

	// B.NE end
	p = obj.Appendp(p, newprog)
	p.As = ABNE
	p.To.Type = obj.TYPE_BRANCH
	p.Pcond = end

	// ADD $4, R13, R4
	p = obj.Appendp(p, newprog)
	p.As = AADD
	p.From.Type = obj.TYPE_CONST
	p.From.Offset = 4
	p.Reg = REG_R13
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REG_R4

	// MOVW R4, panic_argp(R1)
	p = obj.Appendp(p, newprog)
	p.As = AMOVW
	p.From.Type = obj.TYPE_REG
	p.From.Reg = REG_R4
	p.To.Type = obj.TYPE_MEM
	p.To.Reg = REG_R1
	p.To.Offset = 0 // Panic.argp

	// B end
	p = obj.Appendp(p, newprog)
	p.As = AB
	p.To.Type = obj.TYPE_BRANCH
	p.Pcond = end

	// reset for subsequent passes
	p = end
	}

	case obj.ARET:
	nocache(p)
	if cursym.Func.Text.Mark&LEAF != 0 {
	if autosize == 0 {
	p.As = AB
	p.From = obj.Addr{}
	if p.To.Sym != nil { // retjmp
	p.To.Type = obj.TYPE_BRANCH
	} else {
	p.To.Type = obj.TYPE_MEM
	p.To.Offset = 0
	p.To.Reg = REGLINK
	}

	break
	}
	}

	p.As = AMOVW
	p.Scond \|= C_PBIT
	p.From.Type = obj.TYPE_MEM
	p.From.Offset = int64(autosize)
	p.From.Reg = REGSP
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REGPC

	// If there are instructions following
	// this ARET, they come from a branch
	// with the same stackframe, so no spadj.
	if p.To.Sym != nil { // retjmp
	p.To.Reg = REGLINK
	q2 = obj.Appendp(p, newprog)
	q2.As = AB
	q2.To.Type = obj.TYPE_BRANCH
	q2.To.Sym = p.To.Sym
	p.To.Sym = nil
	p = q2
	}

	case AADD:
	if p.From.Type == obj.TYPE_CONST && p.From.Reg == 0 && p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP {
	p.Spadj = int32(-p.From.Offset)
	}

	case ASUB:
	if p.From.Type == obj.TYPE_CONST && p.From.Reg == 0 && p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP {
	p.Spadj = int32(p.From.Offset)
	}

	case ADIV, ADIVU, AMOD, AMODU:
	if cursym.Func.Text.From.Sym.NoSplit() {
	ctxt.Diag("cannot divide in NOSPLIT function")
	}
	const debugdivmod = false
	if debugdivmod {
	break
	}
	if p.From.Type != obj.TYPE_REG {
	break
	}
	if p.To.Type != obj.TYPE_REG {
	break
	}

	// Make copy because we overwrite p below.
	q1 := *p
	if q1.Reg == REGTMP \|\| q1.Reg == 0 && q1.To.Reg == REGTMP {
	ctxt.Diag("div already using REGTMP: %v", p)
	}

	/* MOV m(g),REGTMP */
	p.As = AMOVW
	p.Pos = q1.Pos
	p.From.Type = obj.TYPE_MEM
	p.From.Reg = REGG
	p.From.Offset = 6 * 4 // offset of g.m
	p.Reg = 0
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REGTMP

	/* MOV a,m_divmod(REGTMP) */
	p = obj.Appendp(p, newprog)
	p.As = AMOVW
	p.Pos = q1.Pos
	p.From.Type = obj.TYPE_REG
	p.From.Reg = q1.From.Reg
	p.To.Type = obj.TYPE_MEM
	p.To.Reg = REGTMP
	p.To.Offset = 8 * 4 // offset of m.divmod

	/* MOV b, R8 */
	p = obj.Appendp(p, newprog)
	p.As = AMOVW
	p.Pos = q1.Pos
	p.From.Type = obj.TYPE_REG
	p.From.Reg = q1.Reg
	if q1.Reg == 0 {
	p.From.Reg = q1.To.Reg
	}
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REG_R8
	p.To.Offset = 0

	/* CALL appropriate */
	p = obj.Appendp(p, newprog)
	p.As = ABL
	p.Pos = q1.Pos
	p.To.Type = obj.TYPE_BRANCH
	switch o {
	case ADIV:
	p.To.Sym = symdiv
	case ADIVU:
	p.To.Sym = symdivu
	case AMOD:
	p.To.Sym = symmod
	case AMODU:
	p.To.Sym = symmodu
	}

	/* MOV REGTMP, b */
	p = obj.Appendp(p, newprog)
	p.As = AMOVW
	p.Pos = q1.Pos
	p.From.Type = obj.TYPE_REG
	p.From.Reg = REGTMP
	p.From.Offset = 0
	p.To.Type = obj.TYPE_REG
	p.To.Reg = q1.To.Reg

	case AMOVW:
	if (p.Scond&C_WBIT != 0) && p.To.Type == obj.TYPE_MEM && p.To.Reg == REGSP {
	p.Spadj = int32(-p.To.Offset)
	}
	if (p.Scond&C_PBIT != 0) && p.From.Type == obj.TYPE_MEM && p.From.Reg == REGSP && p.To.Reg != REGPC {
	p.Spadj = int32(-p.From.Offset)
	}
	if p.From.Type == obj.TYPE_ADDR && p.From.Reg == REGSP && p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP {
	p.Spadj = int32(-p.From.Offset)
	}

	case obj.AGETCALLERPC:
	if cursym.Leaf() {
	/* MOVW LR, Rd */
	p.As = AMOVW
	p.From.Type = obj.TYPE_REG
	p.From.Reg = REGLINK
	} else {
	/* MOVW (RSP), Rd */
	p.As = AMOVW
	p.From.Type = obj.TYPE_MEM
	p.From.Reg = REGSP
	}
	}
	}
	}

	func (c ctxt5) stacksplit(p obj.Prog, framesize int32) *obj.Prog {
	// MOVW g_stackguard(g), R1
	p = obj.Appendp(p, c.newprog)

	p.As = AMOVW
	p.From.Type = obj.TYPE_MEM
	p.From.Reg = REGG
	p.From.Offset = 2 * int64(c.ctxt.Arch.PtrSize) // G.stackguard0
	if c.cursym.CFunc() {
	p.From.Offset = 3 * int64(c.ctxt.Arch.PtrSize) // G.stackguard1
	}
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REG_R1

	if framesize <= objabi.StackSmall {
	// small stack: SP < stackguard
	// CMP stackguard, SP
	p = obj.Appendp(p, c.newprog)

	p.As = ACMP
	p.From.Type = obj.TYPE_REG
	p.From.Reg = REG_R1
	p.Reg = REGSP
	} else if framesize <= objabi.StackBig {
	// large stack: SP-framesize < stackguard-StackSmall
	// MOVW $-(framesize-StackSmall)(SP), R2
	// CMP stackguard, R2
	p = obj.Appendp(p, c.newprog)

	p.As = AMOVW
	p.From.Type = obj.TYPE_ADDR
	p.From.Reg = REGSP
	p.From.Offset = -(int64(framesize) - objabi.StackSmall)
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REG_R2

	p = obj.Appendp(p, c.newprog)
	p.As = ACMP
	p.From.Type = obj.TYPE_REG
	p.From.Reg = REG_R1
	p.Reg = REG_R2
	} else {
	// Such a large stack we need to protect against wraparound
	// if SP is close to zero.
	// SP-stackguard+StackGuard < framesize + (StackGuard-StackSmall)
	// The +StackGuard on both sides is required to keep the left side positive:
	// SP is allowed to be slightly below stackguard. See stack.h.
	// CMP $StackPreempt, R1
	// MOVW.NE $StackGuard(SP), R2
	// SUB.NE R1, R2
	// MOVW.NE $(framesize+(StackGuard-StackSmall)), R3
	// CMP.NE R3, R2
	p = obj.Appendp(p, c.newprog)

	p.As = ACMP
	p.From.Type = obj.TYPE_CONST
	p.From.Offset = int64(uint32(objabi.StackPreempt & (1<<32 - 1)))
	p.Reg = REG_R1

	p = obj.Appendp(p, c.newprog)
	p.As = AMOVW
	p.From.Type = obj.TYPE_ADDR
	p.From.Reg = REGSP
	p.From.Offset = int64(objabi.StackGuard)
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REG_R2
	p.Scond = C_SCOND_NE

	p = obj.Appendp(p, c.newprog)
	p.As = ASUB
	p.From.Type = obj.TYPE_REG
	p.From.Reg = REG_R1
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REG_R2
	p.Scond = C_SCOND_NE

	p = obj.Appendp(p, c.newprog)
	p.As = AMOVW
	p.From.Type = obj.TYPE_ADDR
	p.From.Offset = int64(framesize) + (int64(objabi.StackGuard) - objabi.StackSmall)
	p.To.Type = obj.TYPE_REG
	p.To.Reg = REG_R3
	p.Scond = C_SCOND_NE

	p = obj.Appendp(p, c.newprog)
	p.As = ACMP
	p.From.Type = obj.TYPE_REG
	p.From.Reg = REG_R3
	p.Reg = REG_R2
	p.Scond = C_SCOND_NE
	}

	// BLS call-to-morestack
	bls := obj.Appendp(p, c.newprog)
	bls.As = ABLS
	bls.To.Type = obj.TYPE_BRANCH

	var last *obj.Prog
	for last = c.cursym.Func.Text; last.Link != nil; last = last.Link {
	}

	// Now we are at the end of the function, but logically
	// we are still in function prologue. We need to fix the
	// SP data and PCDATA.
	spfix := obj.Appendp(last, c.newprog)
	spfix.As = obj.ANOP
	spfix.Spadj = -framesize

	pcdata := c.ctxt.EmitEntryLiveness(c.cursym, spfix, c.newprog)

	// MOVW LR, R3
	movw := obj.Appendp(pcdata, c.newprog)
	movw.As = AMOVW
	movw.From.Type = obj.TYPE_REG
	movw.From.Reg = REGLINK
	movw.To.Type = obj.TYPE_REG
	movw.To.Reg = REG_R3

	bls.Pcond = movw

	// BL runtime.morestack
	call := obj.Appendp(movw, c.newprog)
	call.As = obj.ACALL
	call.To.Type = obj.TYPE_BRANCH
	morestack := "runtime.morestack"
	switch {
	case c.cursym.CFunc():
	morestack = "runtime.morestackc"
	case !c.cursym.Func.Text.From.Sym.NeedCtxt():
	morestack = "runtime.morestack_noctxt"
	}
	call.To.Sym = c.ctxt.Lookup(morestack)

	// B start
	b := obj.Appendp(call, c.newprog)
	b.As = obj.AJMP
	b.To.Type = obj.TYPE_BRANCH
	b.Pcond = c.cursym.Func.Text.Link
	b.Spadj = +framesize

	return bls
	}

	var unaryDst = map[obj.As]bool{
	ASWI: true,
	AWORD: true,
	}

	var Linkarm = obj.LinkArch{
	Arch: sys.ArchARM,
	Init: buildop,
	Preprocess: preprocess,
	Assemble: span5,
	Progedit: progedit,
	UnaryDst: unaryDst,
	DWARFRegisters: ARMDWARFRegisters,
	}