func readprog(b *bufio.Reader, p *liblink.Prog) {
if !undef[p] {
panic("double-def")
}
delete(undef, p)
p.Pc = rdint(b)
p.Lineno = int32(rdint(b))
p.Link = rdprog(b)
p.As = int16(rdint(b))
p.Reg = uint8(rdint(b))
p.Scond = uint8(rdint(b))
p.Width = int8(rdint(b))
readaddr(b, &p.From)
readaddr(b, &p.To)
}
func stacksplit(ctxt *liblink.Link, p *liblink.Prog, framesize int32, noctxt int) *liblink.Prog {
// MOVW g_stackguard(g), R1
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.From.Type_ = D_OREG
p.From.Reg = REGG
p.From.Offset = 2 * int64(ctxt.Arch.Ptrsize) // G.stackguard0
if ctxt.Cursym.Cfunc != 0 {
p.From.Offset = 3 * int64(ctxt.Arch.Ptrsize) // G.stackguard1
}
p.To.Type_ = D_REG
p.To.Reg = 1
if framesize <= liblink.StackSmall {
// small stack: SP < stackguard
// CMP stackguard, SP
p = liblink.Appendp(ctxt, p)
p.As = ACMP
p.From.Type_ = D_REG
p.From.Reg = 1
p.Reg = REGSP
} else if framesize <= liblink.StackBig {
// large stack: SP-framesize < stackguard-StackSmall
// MOVW $-framesize(SP), R2
// CMP stackguard, R2
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.From.Type_ = D_CONST
p.From.Reg = REGSP
p.From.Offset = int64(-framesize)
p.To.Type_ = D_REG
p.To.Reg = 2
p = liblink.Appendp(ctxt, p)
p.As = ACMP
p.From.Type_ = D_REG
p.From.Reg = 1
p.Reg = 2
} 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 = liblink.Appendp(ctxt, p)
p.As = ACMP
p.From.Type_ = D_CONST
p.From.Offset = int64(uint32(liblink.StackPreempt & (1<<32 - 1)))
p.Reg = 1
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.From.Type_ = D_CONST
p.From.Reg = REGSP
p.From.Offset = liblink.StackGuard
p.To.Type_ = D_REG
p.To.Reg = 2
p.Scond = C_SCOND_NE
p = liblink.Appendp(ctxt, p)
p.As = ASUB
p.From.Type_ = D_REG
p.From.Reg = 1
p.To.Type_ = D_REG
p.To.Reg = 2
p.Scond = C_SCOND_NE
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.From.Type_ = D_CONST
p.From.Offset = int64(framesize) + (liblink.StackGuard - liblink.StackSmall)
p.To.Type_ = D_REG
p.To.Reg = 3
p.Scond = C_SCOND_NE
p = liblink.Appendp(ctxt, p)
p.As = ACMP
p.From.Type_ = D_REG
p.From.Reg = 3
p.Reg = 2
p.Scond = C_SCOND_NE
}
// MOVW.LS R14, R3
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.Scond = C_SCOND_LS
p.From.Type_ = D_REG
p.From.Reg = REGLINK
p.To.Type_ = D_REG
p.To.Reg = 3
// BL.LS runtime.morestack(SB) // modifies LR, returns with LO still asserted
p = liblink.Appendp(ctxt, p)
p.As = ABL
p.Scond = C_SCOND_LS
p.To.Type_ = D_BRANCH
if ctxt.Cursym.Cfunc != 0 {
p.To.Sym = liblink.Linklookup(ctxt, "runtime.morestackc", 0)
} else {
p.To.Sym = ctxt.Symmorestack[noctxt]
}
// BLS start
p = liblink.Appendp(ctxt, p)
p.As = ABLS
p.To.Type_ = D_BRANCH
p.Pcond = ctxt.Cursym.Text.Link
return p
}
func addstacksplit(ctxt *liblink.Link, cursym *liblink.LSym) {
var p *liblink.Prog
var pl *liblink.Prog
var p1 *liblink.Prog
var p2 *liblink.Prog
var q *liblink.Prog
var q1 *liblink.Prog
var q2 *liblink.Prog
var o int
var autosize int32
var autoffset int32
autosize = 0
if ctxt.Symmorestack[0] == nil {
ctxt.Symmorestack[0] = liblink.Linklookup(ctxt, "runtime.morestack", 0)
ctxt.Symmorestack[1] = liblink.Linklookup(ctxt, "runtime.morestack_noctxt", 0)
}
q = nil
ctxt.Cursym = cursym
if cursym.Text == nil || cursym.Text.Link == nil {
return
}
softfloat(ctxt, cursym)
p = cursym.Text
autoffset = int32(p.To.Offset)
if autoffset < 0 {
autoffset = 0
}
cursym.Locals = autoffset
cursym.Args = p.To.Offset2
if ctxt.Debugzerostack != 0 {
if autoffset != 0 && !(p.Reg&liblink.NOSPLIT != 0) {
// MOVW $4(R13), R1
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.From.Type_ = D_CONST
p.From.Reg = 13
p.From.Offset = 4
p.To.Type_ = D_REG
p.To.Reg = 1
// MOVW $n(R13), R2
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.From.Type_ = D_CONST
p.From.Reg = 13
p.From.Offset = 4 + int64(autoffset)
p.To.Type_ = D_REG
p.To.Reg = 2
// MOVW $0, R3
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.From.Type_ = D_CONST
p.From.Offset = 0
p.To.Type_ = D_REG
p.To.Reg = 3
// L:
// MOVW.nil R3, 0(R1) +4
// CMP R1, R2
// BNE L
pl = liblink.Appendp(ctxt, p)
p = pl
p.As = AMOVW
p.From.Type_ = D_REG
p.From.Reg = 3
p.To.Type_ = D_OREG
p.To.Reg = 1
p.To.Offset = 4
p.Scond |= C_PBIT
p = liblink.Appendp(ctxt, p)
p.As = ACMP
p.From.Type_ = D_REG
p.From.Reg = 1
p.Reg = 2
p = liblink.Appendp(ctxt, p)
p.As = ABNE
p.To.Type_ = D_BRANCH
p.Pcond = pl
}
}
/*
* find leaf subroutines
* strip NOPs
* expand RET
* expand BECOME pseudo
*/
for p = cursym.Text; p != nil; p = p.Link {
switch p.As {
case ACASE:
if ctxt.Flag_shared != 0 {
linkcase(p)
}
case ATEXT:
p.Mark |= LEAF
case ARET:
break
case ADIV,
ADIVU,
AMOD,
AMODU:
q = p
if ctxt.Sym_div == nil {
initdiv(ctxt)
}
cursym.Text.Mark &^= LEAF
continue
case ANOP:
q1 = p.Link
q.Link = q1 /* q is non-nop */
if q1 != nil {
q1.Mark |= p.Mark
}
continue
case ABL,
ABX,
ADUFFZERO,
ADUFFCOPY:
cursym.Text.Mark &^= LEAF
fallthrough
case ABCASE,
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 == ANOP {
q1 = q1.Link
p.Pcond = q1
}
}
break
}
q = p
}
for p = cursym.Text; p != nil; p = p.Link {
o = int(p.As)
switch o {
case ATEXT:
autosize = int32(p.To.Offset + 4)
if autosize <= 4 {
if cursym.Text.Mark&LEAF != 0 {
p.To.Offset = -4
autosize = 0
}
}
if !(autosize != 0) && !(cursym.Text.Mark&LEAF != 0) {
if ctxt.Debugvlog != 0 {
fmt.Fprintf(ctxt.Bso, "save suppressed in: %s\n", cursym.Name)
liblink.Bflush(ctxt.Bso)
}
cursym.Text.Mark |= LEAF
}
if cursym.Text.Mark&LEAF != 0 {
cursym.Leaf = 1
if !(autosize != 0) {
break
}
}
if !(p.Reg&liblink.NOSPLIT != 0) {
p = stacksplit(ctxt, p, autosize, bool2int(!(cursym.Text.Reg&liblink.NEEDCTXT != 0))) // emit split check
}
// MOVW.W R14,$-autosize(SP)
p = liblink.Appendp(ctxt, 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 = int64(-autosize)
p.To.Reg = REGSP
p.Spadj = autosize
if cursym.Text.Reg&liblink.WRAPPER != 0 {
// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
//
// MOVW g_panic(g), R1
// CMP $0, R1
// B.EQ end
// 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)
// end:
// NOP
//
// 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 = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.From.Type_ = D_OREG
p.From.Reg = REGG
p.From.Offset = 4 * int64(ctxt.Arch.Ptrsize) // G.panic
p.To.Type_ = D_REG
p.To.Reg = 1
p = liblink.Appendp(ctxt, p)
p.As = ACMP
p.From.Type_ = D_CONST
p.From.Offset = 0
p.Reg = 1
p = liblink.Appendp(ctxt, p)
p.As = ABEQ
p.To.Type_ = D_BRANCH
p1 = p
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.From.Type_ = D_OREG
p.From.Reg = 1
p.From.Offset = 0 // Panic.argp
p.To.Type_ = D_REG
p.To.Reg = 2
p = liblink.Appendp(ctxt, p)
p.As = AADD
p.From.Type_ = D_CONST
p.From.Offset = int64(autosize) + 4
p.Reg = 13
p.To.Type_ = D_REG
p.To.Reg = 3
p = liblink.Appendp(ctxt, p)
p.As = ACMP
p.From.Type_ = D_REG
p.From.Reg = 2
p.Reg = 3
p = liblink.Appendp(ctxt, p)
p.As = ABNE
p.To.Type_ = D_BRANCH
p2 = p
p = liblink.Appendp(ctxt, p)
p.As = AADD
p.From.Type_ = D_CONST
p.From.Offset = 4
p.Reg = 13
p.To.Type_ = D_REG
p.To.Reg = 4
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.From.Type_ = D_REG
p.From.Reg = 4
p.To.Type_ = D_OREG
p.To.Reg = 1
p.To.Offset = 0 // Panic.argp
p = liblink.Appendp(ctxt, p)
p.As = ANOP
p1.Pcond = p
p2.Pcond = p
}
case ARET:
nocache5(p)
if cursym.Text.Mark&LEAF != 0 {
if !(autosize != 0) {
p.As = AB
p.From = zprg5.From
if p.To.Sym != nil { // retjmp
p.To.Type_ = D_BRANCH
} else {
p.To.Type_ = D_OREG
p.To.Offset = 0
p.To.Reg = REGLINK
}
break
}
}
p.As = AMOVW
p.Scond |= C_PBIT
p.From.Type_ = D_OREG
p.From.Offset = int64(autosize)
p.From.Reg = REGSP
p.To.Type_ = D_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 = liblink.Appendp(ctxt, p)
q2.As = AB
q2.To.Type_ = D_BRANCH
q2.To.Sym = p.To.Sym
p.To.Sym = nil
p = q2
}
case AADD:
if p.From.Type_ == D_CONST && p.From.Reg == NREG && p.To.Type_ == D_REG && p.To.Reg == REGSP {
p.Spadj = int32(-p.From.Offset)
}
case ASUB:
if p.From.Type_ == D_CONST && p.From.Reg == NREG && p.To.Type_ == D_REG && p.To.Reg == REGSP {
p.Spadj = int32(p.From.Offset)
}
case ADIV,
ADIVU,
AMOD,
AMODU:
if ctxt.Debugdivmod != 0 {
break
}
if p.From.Type_ != D_REG {
break
}
if p.To.Type_ != D_REG {
break
}
q1 = p
/* MOV a,4(SP) */
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.Lineno = q1.Lineno
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 */
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.Lineno = q1.Lineno
p.From.Type_ = D_REG
p.From.Reg = int8(q1.Reg)
if q1.Reg == NREG {
p.From.Reg = q1.To.Reg
}
p.To.Type_ = D_REG
p.To.Reg = REGTMP
p.To.Offset = 0
/* CALL appropriate */
p = liblink.Appendp(ctxt, p)
p.As = ABL
p.Lineno = q1.Lineno
p.To.Type_ = D_BRANCH
switch o {
case ADIV:
p.To.Sym = ctxt.Sym_div
case ADIVU:
p.To.Sym = ctxt.Sym_divu
case AMOD:
p.To.Sym = ctxt.Sym_mod
case AMODU:
p.To.Sym = ctxt.Sym_modu
break
}
/* MOV REGTMP, b */
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.Lineno = q1.Lineno
p.From.Type_ = D_REG
p.From.Reg = REGTMP
p.From.Offset = 0
p.To.Type_ = D_REG
p.To.Reg = q1.To.Reg
/* ADD $8,SP */
p = liblink.Appendp(ctxt, p)
p.As = AADD
p.Lineno = q1.Lineno
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
p.Spadj = -8
/* Keep saved LR at 0(SP) after SP change. */
/* MOVW 0(SP), REGTMP; MOVW REGTMP, -8!(SP) */
/* TODO: Remove SP adjustments; see issue 6699. */
q1.As = AMOVW
q1.From.Type_ = D_OREG
q1.From.Reg = REGSP
q1.From.Offset = 0
q1.Reg = NREG
q1.To.Type_ = D_REG
q1.To.Reg = REGTMP
/* SUB $8,SP */
q1 = liblink.Appendp(ctxt, q1)
q1.As = AMOVW
q1.From.Type_ = D_REG
q1.From.Reg = REGTMP
q1.Reg = NREG
q1.To.Type_ = D_OREG
q1.To.Reg = REGSP
q1.To.Offset = -8
q1.Scond |= C_WBIT
q1.Spadj = 8
case AMOVW:
if (p.Scond&C_WBIT != 0) && p.To.Type_ == D_OREG && p.To.Reg == REGSP {
p.Spadj = int32(-p.To.Offset)
}
if (p.Scond&C_PBIT != 0) && p.From.Type_ == D_OREG && p.From.Reg == REGSP && p.To.Reg != REGPC {
p.Spadj = int32(-p.From.Offset)
}
if p.From.Type_ == D_CONST && p.From.Reg == REGSP && p.To.Type_ == D_REG && p.To.Reg == REGSP {
p.Spadj = int32(-p.From.Offset)
}
break
}
}
}