本文整理汇总了Golang中code/google/com/p/rsc/c2go/liblink.Prog.Pcond方法的典型用法代码示例。如果您正苦于以下问题：Golang Prog.Pcond方法的具体用法？Golang Prog.Pcond怎么用？Golang Prog.Pcond使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类code/google/com/p/rsc/c2go/liblink.Prog的用法示例。
在下文中一共展示了Prog.Pcond方法的7个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: xfol
func xfol(ctxt *liblink.Link, p *liblink.Prog, last **liblink.Prog) {
var q *liblink.Prog
var r *liblink.Prog
var a int
var i int
loop:
if p == nil {
return
}
a = p.As
if a == AB {
q = p.Pcond
if q != nil && q.As != ATEXT {
p.Mark |= FOLL
p = q
if p.Mark&FOLL == 0 {
goto loop
}
}
}
if p.Mark&FOLL != 0 {
i = 0
q = p
for ; i < 4; (func() { i++; q = q.Link })() {
if q == *last || q == nil {
break
}
a = q.As
if a == ANOP {
i--
continue
}
if a == AB || (a == ARET && q.Scond == C_SCOND_NONE) || a == ARFE || a == AUNDEF {
goto copy
}
if q.Pcond == nil || (q.Pcond.Mark&FOLL != 0) {
continue
}
if a != ABEQ && a != ABNE {
continue
}
copy:
for {
r = ctxt.Prg()
*r = *p
if r.Mark&FOLL == 0 {
fmt.Printf("can't happen 1\n")
}
r.Mark |= FOLL
if p != q {
p = p.Link
(*last).Link = r
*last = r
continue
}
(*last).Link = r
*last = r
if a == AB || (a == ARET && q.Scond == C_SCOND_NONE) || a == ARFE || a == AUNDEF {
return
}
r.As = ABNE
if a == ABNE {
r.As = ABEQ
}
r.Pcond = p.Link
r.Link = p.Pcond
if r.Link.Mark&FOLL == 0 {
xfol(ctxt, r.Link, last)
}
if r.Pcond.Mark&FOLL == 0 {
fmt.Printf("can't happen 2\n")
}
return
}
}
a = AB
q = ctxt.Prg()
q.As = a
q.Lineno = p.Lineno
q.To.Typ = D_BRANCH
q.To.Offset = p.Pc
q.Pcond = p
p = q
}
p.Mark |= FOLL
(*last).Link = p
*last = p
if a == AB || (a == ARET && p.Scond == C_SCOND_NONE) || a == ARFE || a == AUNDEF {
return
}
if p.Pcond != nil {
if a != ABL && a != ABX && p.Link != nil {
q = liblink.Brchain(ctxt, p.Link)
if a != ATEXT && a != ABCASE {
if q != nil && (q.Mark&FOLL != 0) {
p.As = relinv(a)
p.Link = p.Pcond
p.Pcond = q
}
}
//.........这里部分代码省略.........
示例2: addstacksplit
func addstacksplit(ctxt *liblink.Link, cursym *liblink.LSym) {
var p *liblink.Prog
var q *liblink.Prog
var q1 *liblink.Prog
var autoffset int64
var deltasp int64
var a int
var pcsize int
var i uint32
var textstksiz int64
var textarg int64
if ctxt.Tlsg == nil {
ctxt.Tlsg = liblink.Linklookup(ctxt, "runtime.tlsg", 0)
}
if ctxt.Symmorestack[0] == nil {
if len(morename) > len(ctxt.Symmorestack) {
log.Fatalf("Link.symmorestack needs at least %d elements", len(morename))
}
for i = 0; i < uint32(len(morename)); i++ {
ctxt.Symmorestack[i] = liblink.Linklookup(ctxt, morename[i], 0)
}
}
if ctxt.Headtype == liblink.Hplan9 && ctxt.Plan9privates == nil {
ctxt.Plan9privates = liblink.Linklookup(ctxt, "_privates", 0)
}
ctxt.Cursym = cursym
if cursym.Text == nil || cursym.Text.Link == nil {
return
}
p = cursym.Text
parsetextconst(p.To.Offset, &textstksiz, &textarg)
autoffset = textstksiz
if autoffset < 0 {
autoffset = 0
}
cursym.Args = int(p.To.Offset >> 32)
cursym.Locals = textstksiz
if autoffset < liblink.StackSmall && p.From.Scale&liblink.NOSPLIT == 0 {
for q = p; q != nil; q = q.Link {
if q.As == ACALL {
goto noleaf
}
if (q.As == ADUFFCOPY || q.As == ADUFFZERO) && autoffset >= liblink.StackSmall-8 {
goto noleaf
}
}
p.From.Scale |= liblink.NOSPLIT
noleaf:
}
q = nil
if p.From.Scale&liblink.NOSPLIT == 0 || (p.From.Scale&liblink.WRAPPER != 0) {
p = liblink.Appendp(ctxt, p)
p = load_g_cx(ctxt, p) // load g into CX
}
if cursym.Text.From.Scale&liblink.NOSPLIT == 0 {
p = stacksplit(ctxt, p, autoffset, textarg, bool2int(cursym.Text.From.Scale&liblink.NEEDCTXT == 0), &q) // emit split check
}
if autoffset != 0 {
if autoffset%int64(ctxt.Arch.Regsize) != 0 {
ctxt.Diag("unaligned stack size %d", autoffset)
}
p = liblink.Appendp(ctxt, p)
p.As = AADJSP
p.From.Typ = D_CONST
p.From.Offset = autoffset
p.Spadj = autoffset
} else {
// zero-byte stack adjustment.
// Insert a fake non-zero adjustment so that stkcheck can
// recognize the end of the stack-splitting prolog.
p = liblink.Appendp(ctxt, p)
p.As = ANOP
p.Spadj = -ctxt.Arch.Ptrsize
p = liblink.Appendp(ctxt, p)
p.As = ANOP
p.Spadj = ctxt.Arch.Ptrsize
}
if q != nil {
q.Pcond = p
}
deltasp = autoffset
if cursym.Text.From.Scale&liblink.WRAPPER != 0 {
// g->panicwrap += autoffset + ctxt->arch->regsize;
p = liblink.Appendp(ctxt, p)
p.As = AADDL
p.From.Typ = D_CONST
p.From.Offset = autoffset + int64(ctxt.Arch.Regsize)
indir_cx(ctxt, &p.To)
p.To.Offset = 2 * ctxt.Arch.Ptrsize
}
if ctxt.Debugstack > 1 && autoffset != 0 {
// 6l -K -K means double-check for stack overflow
// even after calling morestack and even if the
// function is marked as nosplit.
p = liblink.Appendp(ctxt, p)
p.As = AMOVQ
indir_cx(ctxt, &p.From)
p.From.Offset = 0
p.To.Typ = D_BX
p = liblink.Appendp(ctxt, p)
//.........这里部分代码省略.........
示例3: stacksplit
//.........这里部分代码省略.........
p.As = AMOVW
p.From.Typ = D_CONST
p.From.Reg = REGSP
p.From.Offset = -framesize
p.To.Typ = D_REG
p.To.Reg = 2
p = liblink.Appendp(ctxt, p)
p.As = ACMP
p.From.Typ = 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.Typ = D_CONST
p.From.Offset = int64(uint32(liblink.StackPreempt & 0xFFFFFFFF))
p.Reg = 1
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.From.Typ = D_CONST
p.From.Reg = REGSP
p.From.Offset = liblink.StackGuard
p.To.Typ = D_REG
p.To.Reg = 2
p.Scond = C_SCOND_NE
p = liblink.Appendp(ctxt, p)
p.As = ASUB
p.From.Typ = D_REG
p.From.Reg = 1
p.To.Typ = D_REG
p.To.Reg = 2
p.Scond = C_SCOND_NE
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.From.Typ = D_CONST
p.From.Offset = framesize + (liblink.StackGuard - liblink.StackSmall)
p.To.Typ = D_REG
p.To.Reg = 3
p.Scond = C_SCOND_NE
p = liblink.Appendp(ctxt, p)
p.As = ACMP
p.From.Typ = D_REG
p.From.Reg = 3
p.Reg = 2
p.Scond = C_SCOND_NE
}
// MOVW.LS $framesize, R1
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.Scond = C_SCOND_LS
p.From.Typ = D_CONST
p.From.Offset = framesize
p.To.Typ = D_REG
p.To.Reg = 1
// MOVW.LS $args, R2
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.Scond = C_SCOND_LS
p.From.Typ = D_CONST
arg = ctxt.Cursym.Text.To.Offset2
if arg == 1 { // special marker for known 0
arg = 0
}
if arg&3 != 0 {
ctxt.Diag("misaligned argument size in stack split")
}
p.From.Offset = int64(arg)
p.To.Typ = D_REG
p.To.Reg = 2
// MOVW.LS R14, R3
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.Scond = C_SCOND_LS
p.From.Typ = D_REG
p.From.Reg = REGLINK
p.To.Typ = 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.Typ = D_BRANCH
p.To.Sym = ctxt.Symmorestack[noctxt]
// BLS start
p = liblink.Appendp(ctxt, p)
p.As = ABLS
p.To.Typ = D_BRANCH
p.Pcond = ctxt.Cursym.Text.Link
return p
}示例4: addstacksplit
func addstacksplit(ctxt *liblink.Link, cursym *liblink.LSym) {
var p *liblink.Prog
var pl *liblink.Prog
var q *liblink.Prog
var q1 *liblink.Prog
var q2 *liblink.Prog
var o int
var autosize int64
var autoffset int64
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 = 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.Typ = D_CONST
p.From.Reg = 13
p.From.Offset = 4
p.To.Typ = D_REG
p.To.Reg = 1
// MOVW $n(R13), R2
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.From.Typ = D_CONST
p.From.Reg = 13
p.From.Offset = 4 + autoffset
p.To.Typ = D_REG
p.To.Reg = 2
// MOVW $0, R3
p = liblink.Appendp(ctxt, p)
p.As = AMOVW
p.From.Typ = D_CONST
p.From.Offset = 0
p.To.Typ = 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.Typ = D_REG
p.From.Reg = 3
p.To.Typ = D_OREG
p.To.Reg = 1
p.To.Offset = 4
p.Scond |= C_PBIT
p = liblink.Appendp(ctxt, p)
p.As = ACMP
p.From.Typ = D_REG
p.From.Reg = 1
p.Reg = 2
p = liblink.Appendp(ctxt, p)
p.As = ABNE
p.To.Typ = 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)
}
//.........这里部分代码省略.........
示例5: xfol
func xfol(ctxt *liblink.Link, p *liblink.Prog, last **liblink.Prog) {
var q *liblink.Prog
var i int
var a int
loop:
if p == nil {
return
}
if p.As == AJMP {
q = p.Pcond
if q != nil && q.As != ATEXT {
/* mark instruction as done and continue layout at target of jump */
p.Mark = 1
p = q
if p.Mark == 0 {
goto loop
}
}
}
if p.Mark != 0 {
/*
* p goes here, but already used it elsewhere.
* copy up to 4 instructions or else branch to other copy.
*/
i = 0
q = p
for ; i < 4; (func() { i++; q = q.Link })() {
if q == nil {
break
}
if q == *last {
break
}
a = q.As
if a == ANOP {
i--
continue
}
if nofollow(a) || pushpop(a) != 0 {
break // NOTE(rsc): arm does goto copy
}
if q.Pcond == nil || q.Pcond.Mark != 0 {
continue
}
if a == ACALL || a == ALOOP {
continue
}
for {
if p.As == ANOP {
p = p.Link
continue
}
q = liblink.Copyp(ctxt, p)
p = p.Link
q.Mark = 1
(*last).Link = q
*last = q
if q.As != a || q.Pcond == nil || q.Pcond.Mark != 0 {
continue
}
q.As = relinv(q.As)
p = q.Pcond
q.Pcond = q.Link
q.Link = p
xfol(ctxt, q.Link, last)
p = q.Link
if p.Mark != 0 {
return
}
goto loop /* */
}
}
q = ctxt.Prg()
q.As = AJMP
q.Lineno = p.Lineno
q.To.Typ = D_BRANCH
q.To.Offset = p.Pc
q.Pcond = p
p = q
}
/* emit p */
p.Mark = 1
(*last).Link = p
*last = p
a = p.As
/* continue loop with what comes after p */
if nofollow(a) {
return
}
if p.Pcond != nil && a != ACALL {
/*
* some kind of conditional branch.
* recurse to follow one path.
* continue loop on the other.
*/
q = liblink.Brchain(ctxt, p.Pcond)
if q != nil {
p.Pcond = q
}
q = liblink.Brchain(ctxt, p.Link)
//.........这里部分代码省略.........
示例6: stacksplit
// Append code to p to check for stack split.
// Appends to (does not overwrite) p.
// Assumes g is in CX.
// Returns last new instruction.
// On return, *jmpok is the instruction that should jump
// to the stack frame allocation if no split is needed.
func stacksplit(ctxt *liblink.Link, p *liblink.Prog, framesize int64, noctxt int, jmpok **liblink.Prog) *liblink.Prog {
var q *liblink.Prog
var q1 *liblink.Prog
var arg int
if ctxt.Debugstack != 0 {
// 8l -K means check not only for stack
// overflow but stack underflow.
// On underflow, INT 3 (breakpoint).
// Underflow itself is rare but this also
// catches out-of-sync stack guard info.
p = liblink.Appendp(ctxt, p)
p.As = ACMPL
p.From.Typ = D_INDIR + D_CX
p.From.Offset = 4
p.To.Typ = D_SP
p = liblink.Appendp(ctxt, p)
p.As = AJCC
p.To.Typ = D_BRANCH
p.To.Offset = 4
q1 = p
p = liblink.Appendp(ctxt, p)
p.As = AINT
p.From.Typ = D_CONST
p.From.Offset = 3
p = liblink.Appendp(ctxt, p)
p.As = ANOP
q1.Pcond = p
}
q1 = nil
if framesize <= liblink.StackSmall {
// small stack: SP <= stackguard
// CMPL SP, stackguard
p = liblink.Appendp(ctxt, p)
p.As = ACMPL
p.From.Typ = D_SP
p.To.Typ = D_INDIR + D_CX
} else if framesize <= liblink.StackBig {
// large stack: SP-framesize <= stackguard-StackSmall
// LEAL -(framesize-StackSmall)(SP), AX
// CMPL AX, stackguard
p = liblink.Appendp(ctxt, p)
p.As = ALEAL
p.From.Typ = D_INDIR + D_SP
p.From.Offset = -(framesize - liblink.StackSmall)
p.To.Typ = D_AX
p = liblink.Appendp(ctxt, p)
p.As = ACMPL
p.From.Typ = D_AX
p.To.Typ = D_INDIR + D_CX
} 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.
//
// Preemption sets stackguard to StackPreempt, a very large value.
// That breaks the math above, so we have to check for that explicitly.
// MOVL stackguard, CX
// CMPL CX, $StackPreempt
// JEQ label-of-call-to-morestack
// LEAL StackGuard(SP), AX
// SUBL stackguard, AX
// CMPL AX, $(framesize+(StackGuard-StackSmall))
p = liblink.Appendp(ctxt, p)
p.As = AMOVL
p.From.Typ = D_INDIR + D_CX
p.From.Offset = 0
p.To.Typ = D_SI
p = liblink.Appendp(ctxt, p)
p.As = ACMPL
p.From.Typ = D_SI
p.To.Typ = D_CONST
p.To.Offset = int64(uint32(liblink.StackPreempt & 0xFFFFFFFF))
p = liblink.Appendp(ctxt, p)
p.As = AJEQ
p.To.Typ = D_BRANCH
q1 = p
p = liblink.Appendp(ctxt, p)
p.As = ALEAL
p.From.Typ = D_INDIR + D_SP
p.From.Offset = liblink.StackGuard
p.To.Typ = D_AX
p = liblink.Appendp(ctxt, p)
p.As = ASUBL
p.From.Typ = D_SI
p.From.Offset = 0
p.To.Typ = D_AX
p = liblink.Appendp(ctxt, p)
p.As = ACMPL
p.From.Typ = D_AX
p.To.Typ = D_CONST
p.To.Offset = framesize + (liblink.StackGuard - liblink.StackSmall)
}
//.........这里部分代码省略.........
示例7: addstacksplit
func addstacksplit(ctxt *liblink.Link, cursym *liblink.LSym) {
var p *liblink.Prog
var q *liblink.Prog
var autoffset int64
var deltasp int64
var a int
if ctxt.Symmorestack[0] == nil {
ctxt.Symmorestack[0] = liblink.Linklookup(ctxt, "runtime.morestack", 0)
ctxt.Symmorestack[1] = liblink.Linklookup(ctxt, "runtime.morestack_noctxt", 0)
}
if ctxt.Headtype == liblink.Hplan9 && ctxt.Plan9privates == nil {
ctxt.Plan9privates = liblink.Linklookup(ctxt, "_privates", 0)
}
ctxt.Cursym = cursym
if cursym.Text == nil || cursym.Text.Link == nil {
return
}
p = cursym.Text
autoffset = p.To.Offset
if autoffset < 0 {
autoffset = 0
}
cursym.Locals = autoffset
cursym.Args = p.To.Offset2
q = nil
if p.From.Scale&liblink.NOSPLIT == 0 || (p.From.Scale&liblink.WRAPPER != 0) {
p = liblink.Appendp(ctxt, p)
p = load_g_cx(ctxt, p) // load g into CX
}
if cursym.Text.From.Scale&liblink.NOSPLIT == 0 {
p = stacksplit(ctxt, p, autoffset, bool2int(cursym.Text.From.Scale&liblink.NEEDCTXT == 0), &q) // emit split check
}
if autoffset != 0 {
p = liblink.Appendp(ctxt, p)
p.As = AADJSP
p.From.Typ = D_CONST
p.From.Offset = autoffset
p.Spadj = autoffset
} else {
// zero-byte stack adjustment.
// Insert a fake non-zero adjustment so that stkcheck can
// recognize the end of the stack-splitting prolog.
p = liblink.Appendp(ctxt, p)
p.As = ANOP
p.Spadj = -ctxt.Arch.Ptrsize
p = liblink.Appendp(ctxt, p)
p.As = ANOP
p.Spadj = ctxt.Arch.Ptrsize
}
if q != nil {
q.Pcond = p
}
deltasp = autoffset
if cursym.Text.From.Scale&liblink.WRAPPER != 0 {
// g->panicwrap += autoffset + ctxt->arch->ptrsize;
p = liblink.Appendp(ctxt, p)
p.As = AADDL
p.From.Typ = D_CONST
p.From.Offset = autoffset + ctxt.Arch.Ptrsize
p.To.Typ = D_INDIR + D_CX
p.To.Offset = 2 * ctxt.Arch.Ptrsize
}
if ctxt.Debugzerostack != 0 && autoffset != 0 && cursym.Text.From.Scale&liblink.NOSPLIT == 0 {
// 8l -Z means zero the stack frame on entry.
// This slows down function calls but can help avoid
// false positives in garbage collection.
p = liblink.Appendp(ctxt, p)
p.As = AMOVL
p.From.Typ = D_SP
p.To.Typ = D_DI
p = liblink.Appendp(ctxt, p)
p.As = AMOVL
p.From.Typ = D_CONST
p.From.Offset = autoffset / 4
p.To.Typ = D_CX
p = liblink.Appendp(ctxt, p)
p.As = AMOVL
p.From.Typ = D_CONST
p.From.Offset = 0
p.To.Typ = D_AX
p = liblink.Appendp(ctxt, p)
p.As = AREP
p = liblink.Appendp(ctxt, p)
p.As = ASTOSL
}
for ; p != nil; p = p.Link {
a = p.From.Typ
if a == D_AUTO {
p.From.Offset += deltasp
}
if a == D_PARAM {
p.From.Offset += deltasp + 4
}
a = p.To.Typ
if a == D_AUTO {
p.To.Offset += deltasp
}
if a == D_PARAM {
p.To.Offset += deltasp + 4
}
//.........这里部分代码省略.........